Vererbung C++

D

Dawen

0
Hallo,

ich habe hier ein kleines Problem :

Code: 
#include <iostream>

class X
{
    public:
     int var;
};

class Y
{
    public:
     void printVar(void);
};

class Z : public X, public Y
{
    public:
     void outOut(void);
};


void Y::printVar(void)
{
    std::cout<<var<<std::endl;
}

void Z::outOut(void)
{
    printVar();
}

int main()
{
	Z z;
	z.outOut();
	return 0;
}

In der Klasse X Befindet sich die Variable var, in der Klasse Y, will ich die Aufgeben und in der Klasse Z, ist die Methode zum ausgeben. In der Klasse Y kann ich nun auf var icht zugreifen, ist ja kein Element der Klasse Y, die Klasse Z erbt public die Klassen Y und X.

Frage : Wie schaffe ich es, dass ich in der Klasse Y auf die Variable var von X zugreifen kann , Black Out Syndrom :rolleyes:
 
Frage : Wie schaffe ich es, dass ich in der Klasse Y auf die Variable var von X zugreifen kann , Black Out Syndrom :rolleyes:
Zum Vergrößern anklicken....

Garnicht; aber ich lass mich auch gerne eines besseren belehren;

wenn du die var Membervariable in X static machst; kannst du per X::var in Y darauf zugreifen;

Code: 
#include <iostream>

class X
{
    public:
     static int var;
};

int X::var = 12;

class Y
{
    public:
     void printVar(void);
};

class Z : public X, public Y
{
    public:
     void outOut(void);
};


void Y::printVar(void)
{
    std::cout<<X::var<<std::endl;
}

void Z::outOut(void)
{
    printVar();
}

int main()
{
	Z z;
	z.outOut();
	return 0;
}

Aber in Y ohne irgendeine Verbindung zu X (Vererbung, Komposition) auf die Membervariable var von X zugreifen geht nicht :)

Mit ein paar virtuellen Funktionen könntest dus eventuell noch hinbiegen -> Aber das wär dann für den normalen Gebrauch nicht verwendbar :)
 
Hallo,
doppelt sollte eine Klasse eh nicht erben (mit Außnahme von Interfaces (abstrakte Klasse)), und zwar aus gutem Grund (Java, .NET etc. erlauben eh nur noch einfach Vererbung).

Was du machen kannst:
Z erbt von Y, und Y erbt von X.

Oder du machst X zu einem Interface (abstrakte Klasse), die Y und Z implementieren.
 
Original von Elderan
Hallo,
doppelt sollte eine Klasse eh nicht erben (mit Außnahme von Interfaces (abstrakte Klasse)), und zwar aus gutem Grund (Java, .NET etc. erlauben eh nur noch einfach Vererbung).

Was du machen kannst:
Z erbt von Y, und Y erbt von X.

Oder du machst X zu einem Interface (abstrakte Klasse), die Y und Z implementieren.
Zum Vergrößern anklicken....

Ja, meine Programm besteht nur nich aus den Klassen X,Y,Z ;-) , deine Möglichkeit wäre sicherlich die "beste", ich habe mein Klassendiagramm aber am Ende doch etwas umgebaut, da sowas um 7 Ecken auch nicht besonders sauber ist.
 
Doch, das geht ganz einfach.
Dafür gibts das Schlüsselwort "friend".
http://www.cplusplus.com/doc/tutorial/inheritance.html

Original von Elderan
Hallo,
doppelt sollte eine Klasse eh nicht erben (mit Außnahme von Interfaces (abstrakte Klasse)), und zwar aus gutem Grund (Java, .NET etc. erlauben eh nur noch einfach Vererbung).
Zum Vergrößern anklicken....
Warum denn nicht? Es gibt bestimmt immer eine andere Lösung als Mehrfachvererbung, aber was spricht dagegen?
 
doppelt sollte eine Klasse eh nicht erben (mit Außnahme von Interfaces (abstrakte Klasse)), und zwar aus gutem Grund (Java, .NET etc. erlauben eh nur noch einfach Vererbung).
Zum Vergrößern anklicken....
Würde mich auch mal interessieren warum nicht? Eine public Vererbung sollte immer eine "x ist ein y" Beziehung dastellen. Wenn das nicht zutrifft gibt es in C++ genug andere Möglichkeiten das ganze zu implementieren.

Für den ursprünglichen Code hier mal ein alternativer Ansatz:
Code: 
#include <iostream>

class X
{
public:
	int var;
};

class Y
{
public:
	Y() : foo(new X) {}
	~Y() { delete foo; }
	void printVar(void) const { std::cout<<foo->var<<std::endl; }
private:
	X* foo;    
};

class Z 
{
public:
	Z() : bar(new Y) {}
	~Z() { delete bar; }
	void outOut(void) const { bar->printVar(); }
private:
	Y* bar;
};

int main()
{
	Z z;
	z.outOut();
	return 0;
}

Wie das ganze am besten zu implementieren lässt sich natürlich anhand des vereinfachten Beispiels nicht sagen, jedoch sollte man drauf achten public Vererbung nur einzusetzen wenn die Bedingung einer "ist ein" Beziehung wirklich gegeben ist. Ansonsten halt Containment oder Private Vererbung.
 
Hallo,
eine Möglichkeit wäre auch noch:
Die Klasse Y hat einen Pointer, und im Konstruktor der Klasse wird für den Pointer eine Adresse übergeben.
Auf diese Adresse wird dann der Wert geschrieben.

Beim Initialisieren der Klasse Z über gibt diese der Klasse Y die Adresse der Variable von Klasse X. Hoffentlich versteht man mich ^^

Warum denn nicht?
Zum Vergrößern anklicken....
Unter anderem wegen dem Diamond-Problem, sonst noch ein guter Artikel dazu:
http://www.softwareacademy.de/java/...ehrfachvererbung-versus-Einfachvererbung.aspx
 
Das Diamond Problem lässt sich mit public virtual Vererbung lösen indem nur eine Instanz der Basisklasse zweier abgeleiteter Klassen erzeugt wird. Und ansonsten sehe ich keine Gründe gegen Mehrfachvererbung ausser eventuell halt das es komplexer werden kann aber wenn ich eine einfach Sprache suche nehme ich auch nicht unbedingt C++ ;)

Und meine Lösung macht wenn ich das nun richtig verstanden habe genau das was du sagst, nur das ich mich an den oop Grundsatz halte Variablen und Ojekte so lokal wie möglich zu halten von der Klasse X in meinem Beispiel mal abgesehen.

edit:
Wie sagt man so schön Java hat nur keine Zeiger und Mehrfachvererbung weil die Javaentwickler diese nie verstanden haben :P
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben