Aufgabe zu Klasse mit GraphObj- punkt, rechteck, kreis

[c.groupe]

Hallo mal wieder:

Hier nun eine Aufgabe zu Graphobj:
Seite 1: http://img692.imageshack.us/img692/395/aufgabegraphobj1.jpg
Seite 2: http://img693.imageshack.us/img693/1657/aufgabegraphobj2.jpg

und hier meine Lösung:
was haltet ihr davon, bin aber noch nicht fertig, irgendwie hängts grad.
vielleicht hab ich auch in ein paar punkte zuweit gedacht und zuviel gemacht.
wäre nett wenn ihr es euch mal anschauen würdet.

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

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

class Point
{
public:
	Point() {itsX = itsY = 0;}
	void SetX(int x) { itsX = x; }
	void SetY(int y) { itsY = y; }
	int GetX()const { return itsX;}
	int GetY()const { return itsY;}

private:
	int itsX;
	int itsY;
};

class GraphObj
{
public:
	virtual void flaeche();				// x,y anzeigen
	virtual void distanz();				// abstand zweier obj vom referenzpunkt
	virtual ~GraphObj(){}

protected:
	int itsX, itsY;						// Bezugspunkt
//	GraphObj( int itsX, int itsY);		// allg. Konstruktor
//	GraphObj( const GraphObj& );		// Kopiekonstruktor
//	virtual ~GraphObj(){}				// Destruktor <-- warum kann ich ihn nicht hier lassen?
};

class Rechteck : public GraphObj
{
public:
	virtual void flaeche();
	virtual void distanz();
	Rechteck(int top, int left, int bottom, int right);
	~Rechteck() {}

	int GetTop() const { return itsTop; }
	int GetLeft() const { return itsLeft; }
	int GetBottom() const { return itsBottom; }
	int GetRight() const { return itsRight; }

	Point GetUpperLeft() const { return itsUpperLeft; }
	Point GetLowerLeft() const { return itsLowerLeft; }
	Point GetUpperRight() const { return itsUpperRight; }
	Point GetLowerRight() const { return itsLowerRight; }

	void SetUpperLeft(Point Location) {itsUpperLeft = Location;}
	void SetLowerLeft(Point Location) {itsLowerLeft = Location;}
	void SetUpperRight(Point Location) {itsUpperRight = Location;}
	void SetLowerRight(Point Location) {itsLowerRight = Location;}

	void SetTop(int top) { itsTop = top; }
	void SetLeft (int left) { itsLeft = left; }
	void SetBottom (int bottom) { itsBottom = bottom; }
	void SetRight (int right) { itsRight = right; }

private:
//	Point p1;
//	Point p2;
	Point itsUpperLeft;
	Point itsUpperRight;
	Point itsLowerLeft;
	Point itsLowerRight;
	int itsTop;
	int itsLeft;
	int itsBottom;
	int itsRight;
};

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

	float GetRadius() const { return itsRadius; }
	void SetRadius(int Radius) {itsRadius = Radius;}

	Point GetMittelpunkt() const { return itsMittelpunkt; }
	void SetMittelpunkt(Point Location) {itsMittelpunkt = Location;}

private:
	Point itsMittelpunkt;
	float itsRadius;
};

Rechteck::Rechteck(int top, int left, int bottom, int right)
{
itsTop = top;
itsLeft = left;
itsBottom = bottom;
itsRight = right;

itsUpperLeft.SetX(left);
itsUpperLeft.SetY(top);

itsUpperRight.SetX(right);
itsUpperRight.SetY(top);

itsLowerLeft.SetX(left);
itsLowerLeft.SetY(bottom);

itsLowerRight.SetX(right);
itsLowerRight.SetY(bottom);
}

// Flächenberechnung
void Rechteck::flaeche()
{
	int Width = itsRight - itsLeft;
	int Height = itsTop  - itsBottom;
	cout << "Fläche des Rechtecks wird berechent: " << Width * Height << endl;
}

void Kreis::flaeche()
{
	cout << "Fläche des Kreises wird berechnet: " << ((itsRadius)*(itsRadius))*3.1415 << endl;
}

// Distanzberechnung
void Rechteck::distanz()
{
	int Width = itsRight - itsLeft;
	int Height = itsTop  - itsBottom;
	cout << " Distanz berechen im Rechteck: " << (sqrt((Width*Width) + (Height*Height))) << endl;
}

void Kreis::distanz()
{
	cout << " Distanz berechnen im Kreis: " << itsRadius << endl;
}

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

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

Update.

[l'abra d'or]

Die Klasse Rechteck bitte unbedingt nochmal anschauen!
Was du da an Unwartbarkeit bei den Membern einbaust ist Hammer!
insgesamt 3 mal hast du left, right, top und bottom zu aktualisieren! Tust es aber nicht, so dass je nach getter andere Daten rauskommen. Du wirst nie ein konsistentes Rechteck-Objekt erhalten.

[c.groupe]

l'abra d'or schrieb:

Die Klasse Rechteck bitte unbedingt nochmal anschauen!
Was du da an Unwartbarkeit bei den Membern einbaust ist Hammer!
insgesamt 3 mal hast du left, right, top und bottom zu aktualisieren! Tust es aber nicht, so dass je nach getter andere Daten rauskommen. Du wirst nie ein konsistentes Rechteck-Objekt erhalten.

mhmm ok, sehe ja ein das es da sicherlich noch einen einfacheren weg gibt.
werd mich mal dransetzen ..

[c.groupe]

ok habs komplett geändert:

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

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

class Point
{
public:
	Point() {itsX = itsY = 0;}
	void SetX(int x) { itsX = x; }
	void SetY(int y) { itsY = y; }
	int GetX()const { return itsX;}
	int GetY()const { return itsY;}

private:
	int itsX;
	int itsY;
};

class GraphObj
{
public:
	virtual void flaeche();				// x,y anzeigen
	virtual void distanz();				// abstand zweier obj vom referenzpunkt
	virtual ~GraphObj(){}

protected:
	int itsX, itsY;						// Bezugspunkt
	GraphObj( int itsX, int itsY);		// allg. Konstruktor
	GraphObj( const GraphObj& rhs);		// Kopiekonstruktor
//	virtual ~GraphObj(){}				// Destruktor <-- warum kann ich ihn nicht hier lassen?
};

class Rechteck : public GraphObj
{
	int hoehe, breite;
public:
	virtual void flaeche();
	virtual void distanz();
	Rechteck(int X, int Y, int hoch, int breit);
	~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(int Radius) {itsRadius = Radius;}

	Point GetMittelpunkt() const { return itsMittelpunkt; }
	void SetMittelpunkt(Point Location) {itsMittelpunkt = Location;}

private:
	Point itsMittelpunkt;
	float itsRadius;
};

GraphObj::GraphObj(int aX, int aY) : itsX(aX), itsY(aY) {}
GraphObj::GraphObj(const GraphObj& rhs)
{
	itsX=rhs.itsX;
	itsY=rhs.itsY;
}

Rechteck::Rechteck(int aX, int aY, int h, int b)
: GraphObj(aX,aY), hoehe(h), breite(b) {}

// Flächenberechnung
void Rechteck::flaeche()
{
	int Width = itsY - itsX;
	int Height = hoehe  - breite;
	cout << "Fläche des Rechtecks wird berechent: " << Width * Height << endl;
}

void Kreis::flaeche()
{
	cout << "Fläche des Kreises wird berechnet: " << ((itsRadius)*(itsRadius))*3.1415 << endl;
}

// Distanzberechnung
void Rechteck::distanz()
{
	int Width = itsY - itsX;
	int Height = hoehe  - breite;
	cout << " Distanz berechen im Rechteck: " << (sqrt((Width*Width) + (Height*Height))) << endl;
}

void Kreis::distanz()
{
	cout << " Distanz berechnen im Kreis: " << itsRadius << endl;
}

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

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

hab zwar immernoch ein paar probleme,
vorallem wie ich die main mit einem zeigen auf " 3 " objeke machen soll..

[c.groupe]

oh man, ich bin ziemlich ausgebrannt..

[Nexus]

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.

virtual void flaeche();
virtual void distanz();

Mach diese Funktionen rein virtuell, da sie für GraphObj keine Implementierung haben.

int Width = itsY - itsX; 
int Height = hoehe  - breite

Denk da nochmals in Ruhe drüber nach.

Point itsMittelpunkt;

Was für Informationen enthält dieser Member, welche nicht bereits durch itsX und itsY ausgedrückt werden könnten? Und weshalb inkonsistent sein und einmal eine Punkt-Klasse, ein anderes Mal zwei einzelne Koordinaten speichern?

for (int i=0; i<3; i++)

Wie gross war dein Array nochmal?

c.groupe schrieb:

oh man, ich bin ziemlich ausgebrannt..

Dann beginne nächstes Mal klein und strukturier zuerst die Basisklasse sauber. Programmiere nicht gleich drauf los, sondern überlege dir, was für Funktionen sie anbieten soll und was für Klassen davon abgeleitet werden könnten. Dann machst du weiter mit dem Rechteck, und so weiter...

[c.groupe]

ok danke, ich werds nacher oder morgen nochmal in angriff nehmen

[c.groupe]

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.

Nexus schrieb:

for (int i=0; i<3; i++)

Wie gross war dein Array nochmal?

Steht nun nicht explitzit in der Aufgabe aber er hat dazu gesagt man soll ne main mit einem zeiger auf 3 Objekten machen, weiss nicht nicht welche drei er meint.

Nexus schrieb:

c.groupe schrieb:

oh man, ich bin ziemlich ausgebrannt..

Dann beginne nächstes Mal klein und strukturier zuerst die Basisklasse sauber. Programmiere nicht gleich drauf los, sondern überlege dir, was für Funktionen sie anbieten soll und was für Klassen davon abgeleitet werden könnten. Dann machst du weiter mit dem Rechteck, und so weiter...

Wenn ich alles posen würde hier, wäres doch viel zu viel.
Ich wollte damit nur zum ausdruckbringen, dass ich nach 6h programmieren, einfach nicht mehr kann.

[c.groupe]

So nun mal zurück zur Aufgabe:

Hier nun eine Aufgabe zu Graphobj:
Seite 1: http://img692.imageshack.us/img692/395/aufgabegraphobj1.jpg
Seite 2: http://img693.imageshack.us/img693/1657/aufgabegraphobj2.jpg

zu a: Stellen sie die Klassenhierachie zwischen diesen Klassen dar.

Ich denke er meint damit das:

class Point : public GraphObj

GraphObj die Basisklasse darstellung und Point von GraphObj erbt.
Zumal er ja auch in der Main(): einen Zeigen auf 3 Objekte haben will.

zu b: Es fällt auf, dass die Klasse Point ihre beiden Komponenten vor unbefugtem Zugriff aus einer andern Klasse schützt. Erweitern Sie Point dahingehend, dass beiden Komponenten seperat gelesen(agbefragt) und gesetzt werden kann.

class Point : public GraphObj
{
public:
	Point() {itsX = itsY = 0;}
	void SetX(int x) { itsX = x; }
	void SetY(int y) { itsY = y; }
	int GetX()const { return itsX;}
	int GetY()const { return itsY;}

private:
	int itsX;
	int itsY;
};

Denke das geht soweit damit auch in Ordnung.

zu c: Jedes Objekt von der Klasse GraphObj bzw. von Rechteck und Kreis soll einen Referenzpunkt besitzen (beim Kreis ist es der Mittelpunkt, beim Rechteck dessen Schwerpunkt). Geben sie alle notwendigen Erweiterungen an ( bei dieser Aufgabe soll Vererbung ausgenutzt werden!).

..da bin ich nun dran

[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.