Aufgabe zu Klasse mit GraphObj- punkt, rechteck, kreis

[c.groupe]

soweit bin ich nun:

/*
 * Graphobjekte.cpp
 *
 *  Created on: 31.01.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class GraphObj
{
public:
	virtual void flaeche();			// fläche vom obj
	virtual void distanz();			// abstand zweier obj vom referenzpunkt
	virtual ~GraphObj(){}

protected:
	int itsX, itsY;			 	// Bezugspunkt
	GraphObj() {}
	GraphObj( int itsX, int itsY);		// allg. Konstruktor
	GraphObj( const GraphObj& rhs);		// Kopiekonstruktor
//	virtual ~GraphObj(){}			// Destruktor
};

class Point : public GraphObj
{
public:
	Point() {itsX = itsY = 0;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
	double getX()const { return itsX;}
	double getY()const { return itsY;}

private:
	double itsX;
	double itsY;
};

class Rechteck : public GraphObj
{
public:
	virtual void flaeche();
	virtual void distanz();
	Rechteck() {}
	~Rechteck() {}

private:
	Point p1;
	Point p2;
};

class Kreis : public GraphObj
{
public:
	virtual void flaeche();
	virtual void distanz();
	Kreis(){}
	~Kreis(){}

	float getRadius() const { return itsRadius; }
	void setRadius(float Radius) {itsRadius = Radius;}

	Point getMittelpunkt() const { return itsMittelpunkt; }
	void setMittelpunkt(Point Location) {itsMittelpunkt = Location;}

private:
	Point itsMittelpunkt;
	float itsRadius;
};

// Flächenberechnung
void Rechteck::flaeche()
{
	double x1,x2,y1,y2;
	double laenge, breite;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	laenge  = x2-x1;
	breite  = y2-y1;

	cout << "Flächenberechnung Rechteck: " << laenge*breite << endl;
}

void Kreis::flaeche()
{
	double r;
	setRadius(r);

	cout << "Flächenberechnung Kreis: " << ((r*r)*3.1415) << endl;
}

// Distanzberechnung
void Rechteck::distanz()
{
	double x1,x2,y1,y2;
	double mX, mY;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	mX= ((x1+x2)/2);
	mY= ((y1+y2)/2);

	cout << " Schwerpunkt Rechteck: " << mX << " " << mY << endl;
}

void Kreis::distanz()
{

}

int main()
{
	GraphObj* graphobj[3];
	graphobj[0] = new Point;
	graphobj[1] = new Rechteck;
	graphobj[2] = new Kreis;

	for (int i=0; i<3; i++)
	{
		graphobj[i]->flaeche();
		graphobj[i]->distanz();
		delete graphobj[i];
	}
	return 0;
}

hab allerdings keine ahnung wie ich das mitn mittelpunkt vom kreis machen soll
und dann was er für die distanzberechnung vorsieht.

glaube sqrt(x^2+y2), aber auf was bezogen ? wenn ich doch zwei obj brauch..

[l'abra d'or]

Ein paar Sachen:

* Du hast so ne schöne Point-Klasse. Warum nimmst du die nicht her für deinen Bezugspunkt in GraphObj?

* Du verwendest immer noch keine Initialisierungsliste! Das ist ein wunderschönes C++-Feature, welches auch verwendet werden sollte.

* Point speichert X und Y als int, setter und getter sind aber double...
flaeche und distanz würde ich unbedingt einen return-value verpassen. Ohne dem ist die Funktion nutzlos!

* Rechteck::distanz ist noch ziemliche Katastrophe... x1, x2, y1, y2 sind uninitialisiert und du setzt mit denen p1 und p2 neu! Außerdem ist distanz != schwerpunkt. Und wieder: Hier gehört ein return hin, ohne dem ist die Funktion nutzlos!

So viel erstmal beim ersten Überfliegen..

[l'abra d'or]

c.groupe schrieb:

Nexus schrieb:

Point() {itsX = itsY = 0;}

Verwende dafür die Konstruktor-Initialisierungsliste:

Point() : itsX(0), itsY(0)
{
}

Ausserdem wäre es sicher nicht schlecht, eine Konstruktorüberladung anzubieten, welche den beiden Koordinaten gleich übergebene Werte zuweist.

Wie in der Aufgabenstellung steht sollten die Eigenschaften und Methoden nicht geändert werden.

Du sollst sie ja eben ergänzen! Konstruktorüberladung ist so eine sinnvolle Ergänzung.
Es ist dir lediglich untersagt, die bestehenden Eigenschaften und Methoden zu verändern. Was du übrigens tust, indem du Point von GraphObj ableitest...

// edit:
Ok, der Code verwendet keine Initialisierungsliste, wahrscheinlich weil sie zu dem Zeipunkt noch nicht bekannt ist.

[c.groupe]

so habs mal in double werte abgeändert:

/*
 * Graphobjekte.cpp
 *
 *  Created on: 31.01.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class GraphObj
{
public:
	virtual double flaeche();			// fläche zweier punkte
	virtual double distanz();			// abstand zweier obj vom referenzpunkt
	virtual ~GraphObj(){}

protected:
	int itsX, itsY;						// Bezugspunkt
	GraphObj() {}
//	GraphObj( int itsX, int itsY);		// allg. Konstruktor
//	GraphObj( const GraphObj& rhs);		// Kopiekonstruktor
//	virtual ~GraphObj(){}				// Destruktor
};

class Point : public GraphObj
{
public:
	Point() {itsX = itsY = 0;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
	double getX()const { return itsX;}
	double getY()const { return itsY;}

private:
	double itsX;
	double itsY;
};

class Rechteck : public GraphObj
{
public:
	virtual double flaeche();
	virtual double distanz();
	Rechteck() {}
	~Rechteck() {}

private:
	Point p1;
	Point p2;
};

class Kreis : public GraphObj
{
public:
	virtual double flaeche();
	virtual double distanz();
	Kreis(){}
	~Kreis(){}

	float getRadius() const { return itsRadius; }
	void setRadius(float Radius) {itsRadius = Radius;}

	Point getMittelpunkt() const { return itsMittelpunkt; }
	void setMittelpunkt(Point Location) {itsMittelpunkt = Location;}

private:
	Point itsMittelpunkt;
	float itsRadius;
};

// Flächenberechnung
double Rechteck::flaeche()
{
	double x1,x2,y1,y2;
	double laenge, breite;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	laenge 	= x2-x1;
	breite  = y2-y1;

	cout << "Flächenberechnung Rechteck: ";
	return laenge*breite;
}

double Kreis::flaeche()
{
	double r;
	setRadius(r);

	cout << "Flächenberechnung Kreis: ";
	return ((r*r)*3.1415);
}

// Distanzberechnung
double Rechteck::distanz()
{
	double x1=0,x2=0,y1=0,y2=0;
	double mX=0, mY=0;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	mX= ((x1+x2)/2);
	mY= ((y1+y2)/2);

	cout << " Schwerpunkt Rechteck: " << mX << " " << mY << endl;
	cout << " Distanz Rechteck: ";
	return sqrt((mX*mX)+(mY*mY));
}

double Kreis::distanz()
{
	return 0;
}

int main()
{
	GraphObj* graphobj[3];
	graphobj[0] = new Point;
	graphobj[1] = new Rechteck;
	graphobj[2] = new Kreis;

	for (int i=0; i<3; i++)
	{
		graphobj[i]->flaeche();
		graphobj[i]->distanz();
		delete graphobj[i];
	}
	return 0;
}

mit ist klar das der schwerpunkt keine distanz ist, aber ich brauch ich eben auch.. mhmmm

[l'abra d'or]

Du hast dir den Rest meiner Punkte nicht durchgelesen

Ansonsten steht doch da was du machen sollst: Klassen erweitern
Füge eine Methode
virtual Point bezugspunkt() const =0;
in GraphObj ein. Kreis und Rechteck geben dann entsprechendes zurück.
Weiterhin ein
double distanz( const GraphObj& other ) const;
in GraphObj.
Das kannst du ja direkt in GraphObj implementieren, da sich die Berechnung bei Kreis und Rechteck nicht unterscheiden.

Allerdings muss ich sagen Würd ich distanz in Point implementieren und in GraphObj::distanz einfach

this->bezugspunkt().distanz(other.besugspunkt());

hernehmen.

[c.groupe]

doch hab ich mir durchgelesen, aber ich versteh nicht,
wo mein problem ist, es kann doch garnicht so schwer sein,
die aufgabe ist für 30min angesetzt und ich bin schon nun
zwei tage dran.

/*
 * Graphobjekte.cpp
 *
 *  Created on: 31.01.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class GraphObj
{
public:
	virtual double flaeche();				// fläche zweier punkte
	virtual double distanz();				// abstand zweier obj vom referenzpunkt
	virtual Point bezugspunkt() const =0;
	double distanz( const GraphObj& other ) const;
	virtual ~GraphObj(){}

protected:
	int itsX, itsY;							// Bezugspunkt
	GraphObj() {}
//  double distanz( const GraphObj& other ) const;
//	GraphObj( int itsX, int itsY);			// allg. Konstruktor
//	GraphObj( const GraphObj& rhs);			// Kopiekonstruktor
//	virtual ~GraphObj(){}					// Destruktor
};

class Point : public GraphObj
{
public:
	Point() {itsX = itsY = 0;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
	double getX()const { return itsX;}
	double getY()const { return itsY;}

private:
	double itsX;
	double itsY;
};

class Rechteck : public GraphObj
{
public:
	virtual double flaeche();
	virtual double distanz();
	Rechteck() {}
	~Rechteck() {}

private:
	Point p1;
	Point p2;
};

class Kreis : public GraphObj
{
public:
	virtual double flaeche();
	virtual double distanz();
	Kreis(){}
	~Kreis(){}

	float getRadius() const { return itsRadius; }
	void setRadius(float Radius) {itsRadius = Radius;}

	Point getMittelpunkt() const { return itsMittelpunkt; }
	void setMittelpunkt(Point Location) {itsMittelpunkt = Location;}

private:
	Point itsMittelpunkt;
	float itsRadius;
};

// Flächenberechnung
double GraphObj::flaeche()
{

return 0;
}

double Rechteck::flaeche()
{
	double x1,x2,y1,y2;
	double laenge, breite;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	laenge 	= x2-x1;
	breite  = y2-y1;

	cout << "Flächenberechnung Rechteck: ";
	return laenge*breite;
}

double Kreis::flaeche()
{
	float r=0;
	setRadius(r);

	cout << "Flächenberechnung Kreis: ";
	return ((r*r)*3.1415);
}

// Distanzberechnung
double GraphObj::distanz()
{
return this->bezugspunkt().distanz(other.besugspunkt());
}
double Rechteck::distanz()
{
	double x1=0,x2=0,y1=0,y2=0;
	double mX=0, mY=0;

	p1.setX(x1);		p2.setX(x2);
	p1.setY(y1);		p2.setY(y2);

	mX= ((x1+x2)/2);
	mY= ((y1+y2)/2);

	cout << " Schwerpunkt Rechteck: " << mX << " " << mY << endl;
	cout << " Distanz Rechteck: ";
	return sqrt((mX*mX)+(mY*mY));
}

double Kreis::distanz()
{

	return 0;
}

int main()
{
	GraphObj* graphobj[3];
	graphobj[0] = new Point;
	graphobj[1] = new Rechteck;
	graphobj[2] = new Kreis;

	for (int i=0; i<3; i++)
	{
		graphobj[i]->flaeche();
		graphobj[i]->distanz();
		delete graphobj[i];
	}
	return 0;
}

Sitze einfach aufn Schlauch, denke ich muss mir mal ne andere aufgabe suchen,
damit ich auch mal wieder ein erfolgserlebniss erlebe. ..

[l'abra d'or]

Was bringt eine Funktion distanz, wenn du kein Objekt angeben kannst, zu welchem die Distanz berechnet werden soll?
Die parameterlose distanz() macht also keinen Sinn.

Du brauchst jetzt nur überlegen, wie du am besten deinen Besugspunkt ausrechnest. Für Kreis ist das obersimpel: Du hast ihn bereits als Member - der Mittelpunkt. ->trivial.
Für Rechteck ist es der Schwerpunkt == Mittelpunkt. Am einfachtsen geht das wenn du der Klasse Punkt entsprechende Funktionen verpasst wie operator +, operator/ usw, die das Rechnen vereinfachen.

Ich geb dir hier mal ein wenig Code:

class Point
{
    int x, y;
public:
    Point() { x = y = 0; }
    Point(int x_, int y_)
     : x(x_), y(y_)
    {}
    int getX() const {
        return x;
    }
    int getY() const {
        return y;
    }
};

Point operator +( const Point& left, const Point& right ) {
    return Point( left.getX() + right.getX(), left.getY() + right.getY() );
}

Point operator /( const Point& point, int div )
{
    return Point( point.getX() / div, Point.getY() / div ); // hier wird klar:
    // Es gibt Rundungsfehler, wenn die Division nicht aufgeht!
    // Darum wird in Fällen wo Rechteck ungerade Seitenlängen hat ein falscher Mittelpunkt berechnet!
}

double distanz( const Point& left, const Point& ricght )
{
    // hier Distanz berechnen
}

class GraphObj
{
    // GraphObj braucht gar keine Member!
    // Alles wird über virtuelle Funktionen geregelt.
public:
    virtual Point referenzpunkt() const =0;
};

// Distanz als freie Funktion ist besser,
// da alles über das public-Interface von GraphObj erledigt werden kann
double distanz( const GraphObj& left, const GraphObj& right )
{
    return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
    Point upperLeft, bottomRight; // umbenannt, p1 p1 sind ja sowas von nichtssagend...
public:
    Rechteck( Point ul, Point br )
     : upperLeft(ul), bottomRight(br)
    {}
    Point referenzpunkt() const
    {
        return (upperLeft + bottomRight) / 2;
    }
};

Das was fehlt implemenntierst du in aller Ruhe. Es ist gut, dass du viel übst, aber du solltest dich 1) nicht überfordern und 2) Ruhe bewahren!

[c.groupe]

Ok, muss einfach dran bleiben.

/*
 * Graphobjekte.cpp
 *
 *  Created on: 31.01.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
//	void setX(double x) { itsX = x; }
//	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right)
{
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}

Point operator/ (const Point& point, int div)
{
	return Point ( point.getX() / div , point.getY() / div);
}

double distanz( const Point& left, const Point& right)
{
	return 0; // Distanz: sqrt(x*x +y*y)
}

class GraphObj
{
public:
	virtual Point referenzpunkt() const =0;
};

double distanz( const GraphObj& left, const GraphObj& right)
{
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck( Point ul, Point br)
	: itsUpperLeft(ul), itsBottomRight(br) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }

private:
	// umbenannt von p1 p2
	Point itsUpperLeft;
	Point itsBottomRight;
};

class Kreis : public GraphObj
{
public:
	Kreis(float r)  { itsRadius = r; }
	Point mittelpunkt() const { return itsMittelpunkt; }

private:
	Point itsMittelpunkt;
	float itsRadius;
};

int main()
{

}

habs mal umgeändert und noch Kreis hinzugefügt, richtig so ?

[c.groupe]

hab mal die distanz hinzugefügt

/*
 * Graphobjekte.cpp
 *
 *  Created on: 31.01.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right){
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}

Point operator/ (const Point& point, int div){
	return Point ( point.getX() / div , point.getY() / div);
	// hier wird klar: Es gibt Rundungsfehler, wenn die
	// Division nicht aufgeht! Darum wird in Fällen wo Rechteck
	// ungerade Seitenlängen hat ein falscher Mittelpunkt berechnet!
}

double distanz( const Point& left, const Point& right){
	return sqrt( ( left.getX()*right.getX() )+( left.getY()*right.getY() ) );
}

class GraphObj
{
public:
	GraphObj(){}
//	virtual double flaeche();
	virtual Point referenzpunkt() const =0;
};

double distanz( const GraphObj& left, const GraphObj& right){
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck(){}
	Rechteck( Point ul, Point br)
	: itsUpperLeft(ul), itsBottomRight(br) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }

private:
//  Point p1, p2; umbenannt in:
	Point itsUpperLeft;
	Point itsBottomRight;
};

class Kreis : public GraphObj
{
public:
	Kreis(){}
	Kreis(float r)  { itsRadius = r; }
	Point mittelpunkt() const { return itsMittelpunkt; }

private:
	Point itsMittelpunkt;
	float itsRadius;
};

int main()
{

}

[drakon]

Hast du noch irgendeine konkrete Frage?

[c.groupe]

drakon schrieb:

Hast du noch irgendeine konkrete Frage?

denke mal die distanz ist doch soweit in ordnung.

wie soll ich nun am besten mit den faechen vorrangehen,
auch in der klasse oder besser ausserhalb deklarieren, ich mein
ist ja bei rechteck und kreis nicht gleich.

[drakon]

Ich weiss jetzt zwar nicht genau, was du meinst, aber mach doch eine abstrakte Funktion für die Fläche und implementier die dann spezifisch für den Kreis und das Rechteck.

[c.groupe]

also so ?
So Fläche des Rechtecks klappt noch nicht, zuweit gedacht ?

/*
 * Graphobjekte.cpp
 *
 *  Created on: 04.02.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right){
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}

Point operator- (const Point& left, const Point& right){
	return Point( left.getX()-right.getX(), left.getY()-right.getY() );
}

Point operator* (const Point& point, int other){
	return Point ( point.getX() * other , point.getY() * other);
}

Point operator/ (const Point& point, int div){
	return Point ( point.getX() / div , point.getY() / div);
	// hier wird klar: Es gibt Rundungsfehler, wenn die
	// Division nicht aufgeht! Darum wird in Fällen wo Rechteck
	// ungerade Seitenlängen hat ein falscher Mittelpunkt berechnet!
}

double distanz( const Point& left, const Point& right){
	return sqrt( ( left.getX()*right.getX() )+( left.getY()*right.getY() ) );
}

class GraphObj
{
public:
	GraphObj(){}
	virtual double flaeche()=0;
	virtual Point referenzpunkt() const =0;
};

double distanz( const GraphObj& left, const GraphObj& right){
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck(){}
	Rechteck( Point ul, Point br, Point bl)
	: itsUpperLeft(ul), itsBottomRight(br), itsBottomLeft(bl) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }
	virtual double flaeche()=0;
	void setUpperLeft ( Point upperleft ) { itsUpperLeft = upperleft; }
	Point getUpperLeft() const { return itsUpperLeft; }
	void setBottomRight ( Point bottomright ) { itsBottomRight = bottomright; }
	Point getBottomRight() const { return itsBottomRight; }
	void setBottomLeft ( Point bottomleft ) { itsBottomLeft = bottomleft; }
	Point getBottomLeft() const { return itsBottomLeft; }

private:
//  Point p1, p2; umbenannt in:
	Point itsUpperLeft;
	Point itsBottomRight;
	Point itsBottomLeft;
};

class Kreis : public GraphObj
{
public:
	Kreis(){}
	Kreis(float r)  { itsRadius = r; }
	Point mittelpunkt() const { return itsMittelpunkt; }
	virtual double flaeche()=0;
	void setRadius ( int radius ) { itsRadius = radius; }
	double getRadius() const { return itsRadius; }

private:
	Point itsMittelpunkt;
	float itsRadius;
};

double Rechteck::flaeche()
{
	Point hoehe, breite;
	hoehe = getBottomLeft()-getUpperLeft();
	breite = getBottomLeft()-getBottomRight();
	return hoehe*breite;
}

double Kreis::flaeche()
{
	return getRadius()*getRadius()*3.1415;
}

int main()
{

}

[c.groupe]

manno ,entwerder ich bekomme die fläche von rechteck hin, oder die fläche von kreis, beides klappt irgendwie nicht, weil ich einfach point nicht in double beziehen kann oder umgekehrt, ausserdem ist der radius in float.. ach man

/*
 * Graphobjekte.cpp
 *
 *  Created on: 04.02.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right){
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}
Point operator- (const Point& left, const Point& right){
	return Point( left.getX()-right.getX(), left.getY()-right.getY() );
}
Point operator* (const Point& hoehe, const Point& breite){
	return Point ( hoehe.getX()*breite.getX() , hoehe.getY()*breite.getY() );
}
Point operator/ (const Point& point, int div){
	return Point ( point.getX() / div , point.getY() / div);
	// hier wird klar: Es gibt Rundungsfehler, wenn die
	// Division nicht aufgeht! Darum wird in Fällen wo Rechteck
	// ungerade Seitenlängen hat ein falscher Mittelpunkt berechnet!
}

double distanz( const Point& left, const Point& right){
	return sqrt( ( left.getX()*right.getX() )+( left.getY()*right.getY() ) );
}

class GraphObj
{
public:
	GraphObj(){}
	virtual Point flaeche()=0;
	virtual Point referenzpunkt() const =0;
};

double distanz( const GraphObj& left, const GraphObj& right){
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck(){}
	Rechteck( Point ul, Point br, Point bl)
	: itsUpperLeft(ul), itsBottomRight(br), itsBottomLeft(bl) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }

	virtual Point flaeche()=0;

	void setUpperLeft ( Point upperleft ) { itsUpperLeft = upperleft; }
	void setBottomRight ( Point bottomright ) { itsBottomRight = bottomright; }
	void setBottomLeft ( Point bottomleft ) { itsBottomLeft = bottomleft; }
	Point getUpperLeft() const { return itsUpperLeft; }
	Point getBottomRight() const { return itsBottomRight; }
	Point getBottomLeft() const { return itsBottomLeft; }

private:
//  Point p1, p2; umbenannt in:
	Point itsUpperLeft;
	Point itsBottomRight;
	Point itsBottomLeft;
};

class Kreis : public GraphObj
{
public:
	Kreis(){}
	Kreis(float r)  { itsRadius = r; }
	Point mittelpunkt() const { return itsMittelpunkt; }

	virtual Point flaeche()=0;

	void setRadius ( float radius ) { itsRadius = radius; }
	float getRadius() const { return itsRadius; }

private:
	Point itsMittelpunkt;
	float itsRadius;
};
Point Rechteck::flaeche()
{
	Point hoehe, breite;
	hoehe = getBottomLeft()-getUpperLeft();
	breite = getBottomLeft()-getBottomRight();
	return hoehe*breite;
}
Point Kreis::flaeche()
{
	return getRadius()*getRadius()*3.1415;
}

int main()
{

}

[c.groupe]

und wenn ich meine Main erstelle, mit einem Zeiger auf zwei elemente,
kann ich die funktion flaeche und referenzpunkt nicht abstrackt lassen ,warum ?

/*
 * Graphobjekte.cpp
 *
 *  Created on: 04.02.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right){
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}
Point operator- (const Point& left, const Point& right){
	return Point( left.getX()-right.getX(), left.getY()-right.getY() );
}
Point operator* (const Point& hoehe, const Point& breite){
	return Point ( hoehe.getX()*breite.getX() , hoehe.getY()*breite.getY() );
}
Point operator/ (const Point& point, int div){
	return Point ( point.getX() / div , point.getY() / div);
	// hier wird klar: Es gibt Rundungsfehler, wenn die
	// Division nicht aufgeht! Darum wird in Fällen wo Rechteck
	// ungerade Seitenlängen hat ein falscher Mittelpunkt berechnet!
}

double distanz( const Point& left, const Point& right){
	return sqrt( ( left.getX()*right.getX() )+( left.getY()*right.getY() ) );
}

class GraphObj
{
public:
	GraphObj(){}
	virtual Point flaeche();
	virtual Point referenzpunkt() const;
};

double distanz( const GraphObj& left, const GraphObj& right){
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck(){}
	Rechteck( Point ul, Point br, Point bl)
	: itsUpperLeft(ul), itsBottomRight(br), itsBottomLeft(bl) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }

	virtual Point flaeche();

	void setUpperLeft ( Point upperleft ) { itsUpperLeft = upperleft; }
	void setBottomRight ( Point bottomright ) { itsBottomRight = bottomright; }
	void setBottomLeft ( Point bottomleft ) { itsBottomLeft = bottomleft; }
	Point getUpperLeft() const { return itsUpperLeft; }
	Point getBottomRight() const { return itsBottomRight; }
	Point getBottomLeft() const { return itsBottomLeft; }

private:
//  Point p1, p2; umbenannt in:
	Point itsUpperLeft;
	Point itsBottomRight;
	Point itsBottomLeft;
};

class Kreis : public GraphObj
{
public:
	Kreis(){}
	Kreis(float r)  { itsRadius = r; }
	Point mittelpunkt() const { return itsMittelpunkt; }

	virtual Point flaeche();

	void setRadius ( float radius ) { itsRadius = radius; }
	float getRadius() const { return itsRadius; }

private:
	Point itsMittelpunkt;
	float itsRadius;
};
Point Rechteck::flaeche()
{
	Point hoehe, breite;
	hoehe = getBottomLeft()-getUpperLeft();
	breite = getBottomLeft()-getBottomRight();
	return hoehe*breite;
}
Point Kreis::flaeche()
{
	Point ra, pi;
//	return getRadius()*getRadius();
	return ra*pi;
}

int main()
{
	GraphObj* graphobj[2];
	graphobj[0]	= new Rechteck;
	graphobj[1]	= new Kreis;

	for ( int i=0; i<2; ++i)
		graphobj[i]->flaeche();
	for ( int i=0; i<2; ++i){
		graphobj[i]->referenzpunkt();
		delete graphobj[i];
	}
}

zeigt zwar keine fehler an, aber geht nicht.

[l'abra d'or]

1. Bitte in Zukunft nur noch den relevanten Code posten! Sonst liest sich das keiner mehr durch...
2. flaeche kannst du nicht als Point ausdrücken, oder?
   Ein Punkt ist nämlich per Definition ausdehnungslos, und somit kann er niemals eine Fläche darstellen!
3. "Point hoehe, breite;"
   ist das selbe, Punkt ist ausdehnungslos und blahblah
4. "virtual double flaeche() const =0;"
   also pure virtual deklaration ist nur in GraphObj nötig, in Kreis und Rechteck willst du das ja implementieren!

Hier also der relevante Code:

class GraphObj
{
public:
    virtual double flaeche() const =0;
};

class Rechteck : public GraphObj
{
public:
    double flaeche() const;
};

class Kreis : public GraphObj
{
double m_radius;  // von mir aus auch float, ist wurscht...
public:
    double flaeche() const;
};

double
Kreis::flaeche() const
{
    return m_radius * m_radius * M_PI;  // M_PI kommt aus <cmath>
}

double
Rechteck::flaeche() const
{
    double hoehe = /* tja, du hast zwei Punkte, bottomRight und topLeft,
                      da solltest du doch hoehe und breite ausrechnen können */;
    double breite = /* Berechnung hier */;
    return hoehe * breite;
}

[c.groupe]

danke, habs mal abgeändert:

Stimts mit der höhe ?

hier mein aktueller code: Edit: update.. 1 fehler left

/*
 * Graphobjekte.cpp
 *
 *  Created on: 04.02.2010
 *      Author: c.groupe
 */

#include <iostream>
#include <cmath>
using namespace std;

class Point
{
public:
	Point() {itsX = itsY = 0;}
	Point(double x, double y) : itsX(x), itsY(y) {}
	double getX()const { return itsX;}
	double getY()const { return itsY;}
	void setX(double x) { itsX = x; }
	void setY(double y) { itsY = y; }
private:
	double itsX;
	double itsY;
};

Point operator+ (const Point& left, const Point& right){
	return Point( left.getX()+right.getX(), left.getY()+right.getY() );
}
Point operator- (const Point& left, const Point& right){
	return Point( left.getX()-right.getX(), left.getY()-right.getY() );
}
Point operator* (const Point& hoehe, const Point& breite){
	return Point ( hoehe.getX()*breite.getX() , hoehe.getY()*breite.getY() );
}
Point operator/ (const Point& point, int div){
	return Point ( point.getX() / div , point.getY() / div);
	// Achtung: Rundungsfehler, wenn die Division nicht aufgeht!
	// Rechteck mit ungerade Seitenlängen berechnet einen falschen Mittelpunkt!
}

double distanz( const Point& left, const Point& right){
	return sqrt( ( left.getX()*right.getX() )+( left.getY()*right.getY() ) );
}

class GraphObj
{
public:
//	GraphObj(){}
	virtual double flaeche() const =0;
	virtual Point referenzpunkt() const;
        virtual ~GraphObj() {}
};

double distanz( const GraphObj& left, const GraphObj& right){
	return distanz( left.referenzpunkt(), right.referenzpunkt() );
}

class Rechteck : public GraphObj
{
public:
	Rechteck(){}
	Rechteck( Point ul, Point br)
	: itsUpperLeft(ul), itsBottomRight(br) {}
	Point referenzpunkt() const { return (itsUpperLeft + itsBottomRight) / 2; }

	double flaeche() const;

	void setUpperLeft ( Point upperleft ) { itsUpperLeft = upperleft; }
	void setBottomRight ( Point bottomright ) { itsBottomRight = bottomright; }
	Point getUpperLeft() const { return itsUpperLeft; }
	Point getBottomRight() const { return itsBottomRight; }

private:
//  Point p1, p2; umbenannt in:
	Point itsUpperLeft;
	Point itsBottomRight;
};

class Kreis : public GraphObj
{
public:
	Kreis(){}
	Kreis(float r)  { itsRadius = r; }
	Point referenzpunkt() const { return itsMittelpunkt; }

	double flaeche() const;

	void setRadius ( float radius ) { itsRadius = radius; }
	float getRadius() const { return itsRadius; }

private:
	Point itsMittelpunkt;
	double itsRadius;
};

double Rechteck::flaeche() const
{
        double hoehe = itsUpperLeft.getX()-itsBottomRight.getX();
	double breite = itsBottomRight.getY()-itsUpperLeft.getY();
	return hoehe*breite;
}

double Kreis::flaeche() const
{
return getRadius()*getRadius()*M_PI;
}

int main()
{
	GraphObj* graphobj[2];
	graphobj[0]	= new Rechteck;
	graphobj[1]	= new Kreis;

	for ( int i=0; i<2; ++i)
		graphobj[i]->flaeche();
	for ( int i=0; i<2; ++i){
		graphobj[i]->referenzpunkt();
		delete graphobj[i];
	}
}

[c.groupe]

kanns immernoch nicht starten:

1. undefined reference to vtable for GraphObj' 2\. undefined reference toGraphObj::referenzpunkt() const'

finde aber nicht den fehler..

[l'abra d'or]

Wo ist Kreis::referenzpunkt() const?

[c.groupe]

l'abra d'or schrieb:

Wo ist Kreis::referenzpunkt() const?

...
//  Point mittelpunkt() const { return itsMittelpunkt; }
...
Point referenzpunkt() const { return itsMittelpunkt; }
...

gut habs übersehen.

bleibt noch ein fehler:
" undefined reference to `vtable for GraphObj' "