Übung Hilfe

Hi! Ich habe ein riesen Problem, ich habe mehrere Übungsaufgaben, bei denen ich einfach nciht weiterkomme. Vielleicht kann mir ja jemand helfen. Ich werde einfach mal die erste posten:

Es sei eine abstrakte Klasse GraphElem gegeben. Definieren Sie eine Klasse Rechteck, die öffentlich vom GrapElem
erbt. Eine andere solche Klasse könnte Dreieck sein (wir betrachten hier aber nur GraphElem und Rechteck).
GraphElem habe die Attribute
float x0,y0
und die Methoden
void zeichne()
und
void verschiebe(float x, float y)
In verschiebe() werde zeichne() aufgerufen. Rechteck habe als zusätzliches Attribut
float hoehe und float breite.
Die Klassenhierarchie soll auf Polymorphismus vorbereitet sein. So soll Rechteck die Methode verschiebe (...) von
GraphElem unverändert erben, jedoch zeichnen () überschreiben. Z.B. soll ein Container mit zeigen auf GraphElem
auch alle Nachfahren aufnehmen und diese konsistent zeichnen und verschieben können.
a)
Schreiben Sie die Klassendefinitionen der beiden Klassen, so daß ein Rechteck bei Anwendung der geerbten
Methode verschiebe() richtig gezeichnet wird.
Definieren Sie auch geeignete Konstruktoren, die über entsprechende Parameter optional die Attribute initialisieren
und Destruktoren.
Geben Sie die Implementierungen für die Konstruktoren an. Soweit für zeichne() und verschiebe() Implementierungen
notwendig sind, können Sie die Blöcke durch {...} andeuten. Dasselbe gilt für die Destruktoren, soweit deren
Implementierung nicht leer ist.

prolog

HI

Was hast du denn schon ?
Gib uns den ansatz und wir geben Ratschläge.
Oder sag und warum du nicht auf einen Ansatz kommst.

bisher hab ich:

class GraphElem
{
public:
   GraphElem(float x, float y);
   ~GraphElem {}
   virtual void zeichne();
   void verschiebe(float x, float y);
protected:
   float x0, y0;
}

GraphElem::GraphElem(float x, float y): x0(x), y0(y)
{}

void GraphElem::zeichne()
{...}

void GraphElem:: verschiebe(float x, float y)
{...}

class Rechteck : public GraphElem
{
public:
   Rechteck(float x, float y);
   ~Rechteck {}
   void zeichne(float x, float y);
protected:
   float x1, y1;
}

Rechteck::Rechteck(float x, float y) <- dann ???

void Rechteck::zeichne(float x, float y)

so, mal schauen, was ihr dazu sagt.

aber noch eine frage dazu oder allgemein:
1)wann sind destruktoren virtuell zu deklarieren? sobald eine virtuelle methode in der klasse ist?
2)wann benutzt man den konstruktor der basisklasse im konstr. der abgeleiteten klasse?

Mirauder_Mo

Hallo,

ich bin der meinung die methode zeichne() der klasse GraphElem sollte abstrakt sein, da man ein element hat von dem nicht wirklich definiert ist wie es aussieht kann man es auch nicht zeichnen.

class GraphElem
{
public:
   GraphElem(float x, float y);
   ~GraphElem {}
   virtual void zeichne()=0;  //<= abstrakt und dementsprechend keine implementierung
   void verschiebe(float x, float y);
protected:
   float x0, y0;
}

Ein Rechteck muss mit 4 werten initialisiert werden, x und y wert des Punktes und dann die hoehe und breite (die nach der aufgaben stellung auch hoehe und breite genant werden sollen, x1 und y1 verwirt nur den leser). dann benutzt du die werte die dem konstruktor uebergeben werden welche den Punkt (also x und y) repraesentieren und übergibst sie dem konstruktor der basisklasse (GraphElem) und die beiden anderen speicherst du selbst ab.

class Rechteck : public GraphElem
{
public:
   Rechteck(float x, float y, float h, float b);
   ~Rechteck {}
   void zeichne(float x, float y);
protected:
   float hoehe, breite;
}

Rechteck::Rechteck(float x, float y, float h, float b){
   GraphElem(x,y);
   hoehe = h;
   breite = b;
}

desweiteren ist das eine sehr gaengige aufgabe fuer die w*****einlich tausende loesungen in buechern und im inet zu finden sind