Problem bei Vererbung

Hallo Leute,

ich habe ein etwas schwierig zu erklärendes Problem... na ja ich versuchs einfach mal

ich habe eine abstrakte Klasse(nenne sie jetzt mal Mama) und 2 Klassen die von ihr erben (nenne sie jetzt mal Sohn und Tochter). In Mama habe ich eine abstrakte Methode(ausgabe()) die sowohl in Sohn als auch Tochte neu programmiert werden soll.

Das Ganze wird dann in meinem Hauptprogramm aufgerufen, indem ich ein Objekt Mama erzeuge und ihm je nach Benutzereingabe Sohn oder Tochter zuweise, also:

Mama* dieMama();
if(eingabe == 1) dieMama = new Sohn();
else dieMama = new Tochter();

cout << dieMama->ausgabe();
cout << dieMama->ausgabe();

-->soweit, so gut, das passt alles. In ausgabe() möchte ich nun aber je nach Sohn oder Tochter verschiedene Objekte nutzen, die bei der Ausgabe auch noch bekannt sein müssen. Mein Problem ist nun, dass ich diese Objekte ja eigentlich im Header dieser Unterklassen anlegen müsste, ich abe rdie Informationen darin theoretisch verliere, wenn ich Sohn oder Tochter dem Mama-Objekt zuweise...

versteht ihr mein Problem? (Bin mir grad nicht sicher ob ichs verstehen würde, wenn ich das hier lesen würde...^^)

Habt ihr einen Lösungsvorschlag?

Ganz liebe Grüße
Laura

Skym0sh0

sprich du willst sowas?!

cout << dieMama->ausgabe(fooObjekt);
cout << dieMama->ausgabe(barObjekt);

wenn ja, und du die möglichkeit hast sie zu editieren, dann lass sie von einer klasse erben, welche du als parameter erwartest

class Interface {};

class Foo : public Interface {};
class Bar : public Interface {};

class Mama {
    virtual void ausgabe(Interface const&) = 0;
};

oder du setzt templates ein, oder du nutzt boost any als kapselung für deinen parameter...

edit: wobei, ich bin mir nicht sicher ob ich dein problem verstanden habe...

danke schon mal

aber ich glaube, das war nicht ganz das, was ich suche, ich versuche es noch einmal:

in der Klasse Sohn bräuchte ich ein Objekt vom Typ K1, in Tochter vom Typ K2. K1 und K2 haben nichts miteinander zu tun. Ich würde diese beiden Objekte aber gerne erst in der Klasse selbst erschaffen, da ich sie sonst niergends brauche...

Liebe Grüße
Laura

Ps.: und ich kann sie auch nicht in der Methode erschaffen, da die Objekte erhalten bleiben sollen, also beim 2.Aufruf von Ausgabe möglciherweise etwas anderes passiert als beim ersten, weil das Objekt verändert wurde

Skym0sh0

ja dann erstell sie dir doch als membervariablen...

class Sohn : public Mama {
    Foo m_foo;
};

class Tochter : public Mama {
    Bar m_bar;
};

pyhax

Sowas ?

#include <iostream>
using namespace std;

class K1 {
	public:
		int x;
};

class K2 {
	public:
		int y;
};

class Mama {
	public:
		virtual void ausgabe() = 0;
};

class Sohn: public Mama {
	protected:
		K1 o;
	public:
		Sohn() {o.x=1;}
		void ausgabe() { cout<<o.x<<endl; o.x++; }
};

class Tochter: public Mama {
	protected:
		K2 o;
	public:
		Tochter() {o.y=4;}
		void ausgabe() { cout<<o.y<<endl; o.y++; }
};

int main(int, char**) {
	Mama *m;
	m=new Tochter;
	m->ausgabe();
	delete m;
}

Ich weiß, das Beispiel ist nicht besonders sinvoll -.-

EDIT: Sky war schneller

Genau so was

aber geht das? Gehen die variablen x und y nicht bei der Zuweisung:

m=new Tochter();

verloren? Weil m hat doch eigentlich gar keinen Speicherplatz für x und y, oder?

cooky451

Deswegen nutzt du ja einen Pointer. Pointer sind immer gleich groß, den Speicher für die eigentliche Variable reservierst du mit new.
Damit bei delete auch alles wieder gelöscht wird, brauchst du allerdings noch einen virtuellen Destruktor. (In Mama) (Und die Membervariablen protected zu machen hat hier irgendwie auch keinen Sinn.)

DNKpp

im prinzip ist dein denkansatz gar nciht so verkehrt. du kannst über m nicht direkt die variabeln ansprechen, außer du castest m zu class sohn oder tochter (natürlich mit nachträglich valitäts prüfung). m ist ja NUR ein zeiger, das object erstellst du mit new Object(), und da wird auch der speicher reserviert. m zeigt also nur auf ihm bekannte objecte der class.

hoffe, ist verständlich, was ich meine

DocShoe

Klingt nicht gut. Polymorphismus und virtuelle Methoden dienen dazu, eine Schnittstelle zu definieren, über die abgeleitete Klassen angesprochen werden können ( ausgabe() in deinem Fall). Du möchtest das jetzt aber wieder aufbrechen und damit sind Sohn::ausgabe( const Foo& ) und Tochter::ausgabe( const Bar& ) zwei völlig unterschiedliche Methoden, die nicht über ein gemeinsames Interface angesprochen werden können.

Edit: OMG, Jahre zu spät...

danke euch allen

Jetzt hab ichs begriffen