Forum: C++: Hjälp med en övning, någon?

 
#ifndef SHAPE_H
#define SHAPE_H
 
#include <qwidget.h>
#include "types.h"
 
/* An abstract base class of shapes */
 
class Shape {
public:
    Shape(QWidget *aWidget,const char *n,QColor c,Point p);
    void getName(char *str) const;
    QColor getColor() const;
    void setColor(QColor c);
    Point getPos() const;
    void moveTo(Point p);
    void move(int dx,int dy);
    // pure virtual functions
    virtual void draw() const = 0;      // only implemented
    virtual void erase() const = 0;     // in subclasses
    virtual Shape* clone() const = 0;
protected:
    char myName[100];
    QColor myColor;
    Point myPos;
    QWidget *theWidget;
};
#endif
 

 
 
#ifndef RECT_H
#define RECT_H
 
#include "shape.h"
#include <qwidget.h>
 
class Rectangle : public Shape {
public:
    Rectangle(QWidget *aWidget,const char *name,QColor c,Point p,int w,int h);
    void draw() const;
    void erase() const;
    Rectangle* clone()const;
    int getWidth() const;
    int getHeight() const;
    void setSize(int width,int height);
private:
    int myWidth,myHeight;
    void drawRect(QColor c) const;
};
#endif
 

 
#ifndef ELLIPSE_H
#define ELLIPSE_H
 
#include "shape.h"
#include <qwidget.h>
 
class Ellipse : public Shape {
public:
    Ellipse(QWidget *aWidget,const char *name,QColor c,Point p,int xr,int yr);
    void draw() const;
    void erase() const;
    Ellipse* clone() const;
    int getXradius() const;
    int getYradius() const;
    void setRadius(int xradius,int yradius);
private:
    int myXradius, myYradius;
    void drawEllipse(QColor c) const;
};
#endif
 

 
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include <qwidget.h>
#include "ellipse.h"
 
class Circle : public Ellipse{
public:
     Circle( QWidget *aWidget,const char *name,QColor c,Point p,int radius );
     int getRadius( );
     void setRadius( int radius );
     void draw()const;
     void erase()const;
     Circle* clone()const;
private:
int myRadius;
void drawCircle(QColor c)const;
};
#endif
 

 
#ifndef SQUARE_H
#define SQUARE_H
 
#include "rect.h"
#include <qwidget.h>
 
class Square : public Rectangle{
public:
    Square( QWidget *aWidget,const char *n,QColor c,Point p,int side );
    int getSize();
    void setSize(int size);
    void draw()const;
    void erase()const;
    Square* clone()const;
private:
int mySide;
void drawSquare(QColor c)const;
};
#endif
 
 

 
#ifndef GROUP_H
#define GROUP_H
 
#include <vector.h>
#include "shape.h"
#include <qwidget.h>
 
class Group : public Shape {
public:
    Group( QWidget *aWidget);
    ~Group();
    Group( const Group & );
    Group* clone()const;
//  void move();
    void draw()const;
    void erase()const;
    Group& operator+= ( Shape& sp );
private:
    Vector<Shape*> TheShapeList;
};
#endif
 

 
#include "group.h"
#include <qpainter.h>
 
Group::Group( QWidget *aWidget) : Shape(theWidget,myName,myColor,myPos) { }
 
Group::~Group() {} // Hur gör man?
 
Group::Group( const Group & x) : Shape(x) {
for ( int i = 0; i < TheShapeList.size();i++)
    TheShapeList[i] = x.TheShapeList[i];
}
 
Group* Group::clone()const {
    Group *gp = new Group(theWidget);
    return gp;
}
 
void Group::draw()const { 
    for (int i = 0;i < TheShapeList.size();i++)
 
        TheShapeList[i]->draw();  
}
 
void Group::erase()const { 
    for (int i = 0;i < TheShapeList.size();i++)
 
        TheShapeList[i]->erase();  
}
 
Group& Group::operator+= ( Shape& sp ){
// Ser ej bra ut?? Om vector = 0 --> i+1 ?
    int i = TheShapeList.size();
    TheShapeList[i+1] = sp.clone();
    return *this;
}
 

 
// demonstration of shape groups
#include <qapplication.h>   // Qt
#include <picturedisplay.h>
#include <iostream>
#include "shape.h"
#include "rect.h"
#include "ellipse.h"
#include "square.h"
#include "circle.h"
#include "group.h"
 
using namespace std;
 
void paintMain( int argc, char **argv, PictureDisplay *pd ) {
 
    Ellipse e(pd,"An ellipse",Qt::yellow,Point(100,100),50,30);
    Square s(pd,"A square",Qt::green,Point(300,200),70);
    Circle c(pd,"A circle",Qt::blue,Point(300,200),120);
    Rectangle r(pd,"A rectangle",Qt::magenta,Point(100,100),200,50);
 
    Group g(pd);
 
    pd->askMore();
    g.draw();
 
    (((g += e) += s) += c) += r;
    g.draw();
 
    pd->askMore();
 
/*
    g.move(100,100);
    pd->askMore();
    g.move(-200,0);
    pd->askMore();
    g.move(0,-150);
    pd->askMore();
    g.move(100,0);
 
    pd->askMore( "Beware of the clones!" );
    g.erase();
    pd->askMore();
    Group *gptr = g.clone();
    for ( int i = 0; i < 5; i++ ) {
    	gptr->move(-10,10);
    	g.draw();
	pd->askMore();
    }
    g.erase();
 
 
    pd->askMore( "Test absolute movement of group" );
    Group *gptr2 = gptr->clone();
    for ( int i = 0; i < 5; i++ ) {
    	gptr2->moveTo(Point(100+10*i,100+10*i));
	pd->askMore();
    }
    gptr->erase();
    gptr2->erase();
    pd->askMore( "Test a group of groups" );
 
    // A group consisting of two subgroups of ...
    Group gg(pd), *tmp = g.clone();
    tmp->move(10,-10);   // so its position differs from g's
    tmp->erase();
 
    (gg += g) += *tmp;   // make a hiearchical group
    for ( int i = 0; i < 10; i++ ) {
    	gg.move(20,20);
	pd->askMore();
    }
*/
}
 
int main( int argc, char **argv ) {
 
    QApplication a( argc, argv );
 
    PictureDisplay pd( argc, argv, paintMain );	// create picture display
 
    a.setMainWidget( &pd );			// set main widget
    pd.show();					// show it
    return a.exec();				// start event loop
}
 
 

 
 
#include <qpainter.h>
#include "rect.h"
 
// Constructor
Rectangle::Rectangle(QWidget *aWidget,const char *n,QColor c,Point p,int w,int h)
	: Shape(aWidget,n,c,p), myWidth(w), myHeight(h) { }
 
int Rectangle::getWidth() const { return myWidth; }
 
int Rectangle::getHeight() const { return myHeight; }
 
void Rectangle::setSize(int width,int height) {
 
    erase();
    myWidth = width;
    myHeight = height;
    draw();
}
 
void Rectangle::drawRect(QColor c) const {
 
    // these are QT routines!
    QPainter myPainter( theWidget );	
    QPen pen( c, 2 );
    myPainter.setPen( pen );
    myPainter.drawRect(myPos.x,myPos.y,myWidth,myHeight);
    QFont f( "courier", 12, QFont::Bold );
    myPainter.setFont( f );
myPainter.drawText(myPos.x,myPos.y,myWidth,myHeight,Qt::AlignCenter, myName);
 
}
 
void Rectangle::draw() const { drawRect(myColor); }
 
void Rectangle::erase() const { 
 
    QPainter myPainter(theWidget);	
    drawRect(myPainter.backgroundColor()); 
}
 
Rectangle* Rectangle::clone()const {
 
Rectangle *rp = new Rectangle(theWidget,myName,myColor,myPos,myWidth,myHeight);
return rp;
}
 

 
 
Group& Group::operator+= ( Shape& sp ){
	TheShapeList.push_back(sp);  // testade *sp feldärmed
        return *this;
}
 

 
Group& Group::operator+= ( Shape& sp ){
	// Antar att sp.close() returnerar en pekare?
	TheShapeList.push_back(sp.clone());
	return *this;
}
 

 
Group& Group::operator+= ( Shape& sp ){
	TheShapeList.push_back (&sp);
	return *this;
}
 

 
// demonstration of shape groups
#include <qapplication.h>   // Qt
#include <picturedisplay.h> // added by UH
#include <iostream>
#include "shape.h"
#include "rect.h"
#include "ellipse.h"
#include "square.h"
#include "circle.h"
#include "group.h"
 
using namespace std;
 
void paintMain( int argc, char **argv, PictureDisplay *pd ) {
    Ellipse e(pd,"An ellipse",Qt::yellow,Point(100,100),50,30);
    Square s(pd,"A square",Qt::green,Point(300,200),70);
    Circle c(pd,"A circle",Qt::blue,Point(300,200),120);
    Rectangle r(pd,"A rectangle",Qt::magenta,Point(100,100),200,50);
 
    Group g(pd);
 
    pd->askMore();
 
    g.draw();
    (((g += e) += s) += c) += r;
    g.draw();
    Group *m = g.clone(); // gör en klone
 
    pd->askMore();
    g.erase();
    pd->askMore();
    m->draw();
    pd->askMore(); 
 

 
Group* Group::clone()const {
Group *gp = new Group(theWidget);
return gp;
}
 

 
Group* Group::clone()const {
 
    Group *gp = new Group(theWidget);
    gp->clone();
    return gp;
}
 

 
Group::Group( const Group & x) : Shape(x) { //Aggregat relation mellan Group och Shape: utkärning sker
// djup kopiering
for ( int i = 0; i < TheShapeList.size();i++)
    TheShapeList[i] = x.TheShapeList[i];
}
 

 
Group* Group::clone()const {
 
Group g(?);
// Sen tänkte jag göra en for loop som går igenom alla vector i just den objekt som anropade clone() och push_backa den till den nya objekt g.
 
// Men vet ej hur man ska åstakomma detta, kanske med hjälp av "this"?
 
 

 
Group* Group::clone() const {
	Group *gp = new Group(theWidget);
	gp->clone();
	return gp;
}
 

 
#include <qapplication.h>   // Qt
#include <picturedisplay.h> // added by UH
#include <iostream>
#include "shape.h"
#include "rect.h"
#include "ellipse.h"
#include "square.h"
#include "circle.h"
#include "group.h"
 
using namespace std;
 
void paintMain( int argc, char **argv, PictureDisplay *pd ) {
    Ellipse e(pd,"An ellipse",Qt::yellow,Point(100,100),50,30);
    Square s(pd,"A square",Qt::green,Point(300,200),70);
    Circle c(pd,"A circle",Qt::blue,Point(300,200),120);
    Rectangle r(pd,"A rectangle",Qt::magenta,Point(100,100),200,50);
 
    Group g(pd);
 
    pd->askMore();
    g.draw();
    (((g += e) += s) += c) += r;
    g.draw();
    Group w(g); // Använder kopieringskontruktorn för test
    pd->askMore();
    g.erase();
    pd->askMore();
    w.draw();      // ritar upp inget
    pd->askMore(); 
 
 

 
Group::Group (Group &g)
{
	// Med push_back
	//*
	std::vector<Shape *>::iterator it = g.beginIterator ();
 
	m_shapelist.clear ();
	for (; it != g.endIterator(); ++it) {
		m_shapelist.push_back (*it);
	}
	//*/
 
	// Med std::copy istället
	/*
	m_shapelist.clear ();
	std::copy (g.beginIterator(), g.endIterator(), std::back_inserter(m_shapelist));
	//*/
}
 

 
#ifndef JT_GROUP_H
#define JT_GROUP_H
 
#include "Shape.h"
#include <vector>
 
class Group {
public:
	Group () {}
	Group (Group &);
	~Group () {}
 
	Group &operator+= (Shape &s);
 
	void displayAll ();
 
	std::vector<Shape *>::iterator beginIterator ()	{ return m_shapelist.begin(); }
	std::vector<Shape *>::iterator endIterator ()	{ return m_shapelist.end(); }
 
	inline size_t Size () const { return m_shapelist.size(); }
 
private:
	std::vector<Shape *> m_shapelist;
};
 
#endif
 

 
Group::Group( const Group & x) : Shape(x) {//Aggregat relation basklass=subklass-group: utkärning
 
// Sen gör vi en kopia av group attributen oxo
 
    vector<Shape *>::iterator it = x.beginIterator ();
 
    TheShapeList.clear();
    for (; it != x.endIterator(); ++it) {
   TheShapeList.push_back (*it);
}
 

 
 
#ifndef GROUP_H
#define GROUP_H
#include <vector>
#include "shape.h"
#include <qwidget.h>
 
 
class Group : public Shape {
public:
    Group( QWidget *aWidget); // Konstruktorn
    ~Group();                 // Destruktorn
    Group( const Group & );   // kopieringskonstruktorn	
    Group* clone()const;	             	
//    void move();
    void draw()const;
    void erase()const;
    Group& operator+= ( Shape& sp );
    vector<Shape *>::iterator beginIterator () { return TheShapeList.begin(); }
    vector<Shape *>::iterator endIterator () { return TheShapeList.end(); } 
private:
    Vector<Shape*> TheShapeList;
};
 
#endif
 
 

 
#ifndef _VECTOR_H
#define _VECTOR_H
 
// Vector class interface: support bounds-checked arrays
 
//
// Object: must have zero-parameter constructor and operator=
// CONSTRUCTION: with (a) an integer size only
 
//
 
// ******************PUBLIC OPERATIONS*********************
 
// =                          --> Copying assignment
 
// [ ]                        --> Indexing with bounds check
 
// bool empty( )              --> Return true if Vector empty, false ow
// int size( )                --> Return # elements in Vector
// int capacity( )            --> Return capacity of vector
// void resize( int newSize ) --> Change bounds of Vector
// void reserve( int newCapacity ) --> Change Vector capacity
// void push_back( Object x ) --> Add x at end of Vector
 
#include <stdlib.h>
template <class Object>
 
class Vector {
public:
    explicit Vector( int initSize = 0 )
    	: theSize( initSize ), theCapacity( initSize + SPARE_CAPACITY )
            { objects = new Object[ theCapacity ]; }
    Vector( const Vector & rhs ) : objects( NULL ) { operator=( rhs ); }
    ~Vector( ) { delete [ ] objects; }
 
    bool empty( ) const { return size( ) == 0; }
    int size( ) const { return theSize; }
    int capacity( ) const { return theCapacity; }
 
    Object & operator[]( int index ) {
        if( index < 0 || index >= size( ) )
            throw "Vector::[]: Index out of bounds" ;
        return objects[ index ];
    }
 
    const Object & operator[]( int index ) const  {
        if( index < 0 || index >= size( ) )
        	throw "Vector::[]: Index out of bounds" ;
        return objects[ index ];
    }
    const Vector & operator = ( const Vector & rhs );
    void resize( int newSize );
    void reserve( int newCapacity );
    void push_back( const Object & x );
    enum { SPARE_CAPACITY = 16 };
private:
    int theSize;
    int theCapacity;
    Object *objects;
};
 
template <class Object>
const Vector<Object> & Vector<Object>::operator=( const Vector<Object> & rhs ) {
    if( this != &rhs ) {
        delete [ ] objects;
        theSize = rhs.size( );
        theCapacity = rhs.theCapacity;
 
        objects = new Object[ capacity( ) ];
        for( int k = 0; k < size( ); k++ )
            objects[ k ] = rhs.objects[ k ];
    }
    return *this;
}
 
template <class Object>
void Vector<Object>::resize( int newSize ) {
    if( newSize > theCapacity )
        reserve( newSize * 2 );
    theSize = newSize;
}
template <class Object>
void Vector<Object>::reserve( int newCapacity ) {
    Object *oldArray = objects;
    int numToCopy = newCapacity < theSize ? newCapacity : theSize;
    newCapacity += SPARE_CAPACITY;
    objects = new Object[ newCapacity ];
    for( int k = 0; k < numToCopy; k++ )
        objects[ k ] = oldArray[ k ];
    theSize = numToCopy;
    theCapacity = newCapacity;
    delete [ ] oldArray;
}
 
1template <class Object>
 
void Vector<Object>::push_back( const Object & x ) {
    if( theSize == theCapacity )
        reserve( 2 * theCapacity + 1 );
    objects[ theSize++ ] = x;
}
#endif
 
 

 
// Innan stod det följande:
// Vector<Shape*> TheShapeList;
 
// ...men ska vara med STL (om inte "using namespace std;" används):
std::vector<Shape*> TheShapeList;
 
 

 
Group::Group( const Group & x) : Shape(x) {//Aggregat relation basklass=subklass-group: utkärning
 
std::vector<Shape *>::iterator it = x.beginIterator();
 
     TheShapeList.clear();
     for (; it != x.endIterator(); ++it) {
       TheShapeList.push_back (*it);
 

 
class Group : public Shape {
public:
    Group( QWidget *aWidget); // Konstruktorn
    ~Group();                 // Destruktorn
    Group( const Group & );   // kopieringskonstruktorn	
    Group* clone()const;
//    void move();
    void draw()const;
    void erase()const;
    Group& operator+= ( Shape& sp );
    std::vector<Shape*>::iterator beginIterator();
    std::vector<Shape*>::iterator endIterator();
private:
    std::vector<Shape*> TheShapeList;
};
 

 
// Nu skickas g som en referens, som är 'const'
Group::Group (const Group &g)
{
	// "Kasta om" till en ny referens (g2),
	// och ta samtidigt bort const-delen
	Group &g2 = const_cast<Group&>(g);
 
	// Samma kod, men vi använder g2 istället,
	// som ju inte har 'const'
	std::vector<Shape *>::iterator it = g2.beginIterator ();
 
	m_shapelist.clear ();
	for (; it != g2.endIterator(); ++it) {
		m_shapelist.push_back (*it);
	}
}
 

 
Group* Group::clone()const {
    Group g(theWidget);
    Group *gp = new Group(g); // Använder kopykonstruktorn
 
    return gp;
}
 

 
using namespace std;
 
void paintMain( int argc, char **argv, PictureDisplay *pd ) {
    Ellipse e(pd,"An ellipse",Qt::yellow,Point(100,100),50,30);
    Square s(pd,"A square",Qt::green,Point(300,200),70);
    Circle c(pd,"A circle",Qt::blue,Point(300,200),120);
    Rectangle r(pd,"A rectangle",Qt::magenta,Point(100,100),200,50);
 
    Group g(pd);
    pd->askMore();
 
    g.draw();
    (((g += e) += s) += c) += r;
    g.draw();
    Group *m = g.clone(); // klonar g och retunerar pekare
    pd->askMore();
    g.erase();
    pd->askMore();
    m->draw();
    pd->askMore();    
 

 
Group* Group::clone() const {
	Group *gp = new Group(*this);
	return gp;
}
 

 
void Group::move(int dx,int dy){
    for(int i=0; i < TheShapeList.size();i++)
        (*this).TheShapeList[i]->move(dx,dy);
}
 

 
void Date::setMonth( int mn )
{
   month = mn;            // These three statements  
   this->month = mn;      // are equivalent
   (*this).month = mn;
}
 

 
void Group::move(int dx,int dy){
    for(int i=0; i < TheShapeList.size();i++)
        TheShapeList[i]->move(dx,dy);
}
 

 
        // samma betydelse 
        TheShapeList[i]->move(dx,dy);
        (*this).TheShapeList[i]->move(dx,dy);                 
        this->.TheShapeList[i]->move(dx,dy);