ZFX + Developia

BeRsErKeR hat geschrieben:Gibt es da Lösungen oder plausible Gründe, warum das so gelöst ist?

BeRsErKeR hat geschrieben: Warum ist das so wichtig? Nun nehmen wir mal an wir haben eine Hierarchy aus vielen Ebenen, die alle nur Einfachvererbung nutzen und irgendwo weit unten in der Hierarchy wurde eine virtuelle Vererbung verwendet. Dann muss man für jede dieser Klassen den Konstruktor von Person aufrufen, wobei man das teilweise lieber den Basisklassen überlassen will.

#include <string>

class Virtual
{
public:
	int m_blah;

	Virtual(int x)
	{
		m_blah = x;
	}
};

class Base1 : virtual public Virtual
{
	std::string m_base1String;
public:
	Base1(std::string s) : Virtual(1)
	{
		m_base1String = s;
	}
};

class Base2 : virtual public Virtual
{
	std::string m_base2String;
public:
	Base2(std::string s) : Virtual(2)
	{
		m_base2String = s;
	}
};

class Derived : public Base1, public Base2
{
public:
	// Base1 und Base2 initialisieren Virtual mit verschiedenen Werten, die Basisklasse gibts aber nur einmal, also muss man sich wohl oder übel auf einen Wert festlegen
	Derived(std::string s) : Virtual(3), Base1(s), Base2(s)
	{
	}
};

class MoreDerived : public Derived
{
public:
	MoreDerived(std::string s) : Virtual(4), Derived(s) // hier finde ich es allerdigns überflüssig (GCC besteht aber drauf)
	{
	}
};

BeRsErKeR hat geschrieben:Wenn man nun aber eine neue Klasse einführt (sagen wir mal Chef), die nur von der Klasse Mitarbeiter erbt, so muss scheinbar auch hier der C'tor von Person manuell aufgerufen werden. Ich frage mich nun, ob es einen tieferen Sinn dahinter gibt.

Krishty hat geschrieben:

BeRsErKeR hat geschrieben:Gibt es da Lösungen oder plausible Gründe, warum das so gelöst ist?

(von hier an mutgemaßt)

Weil es konsistenter ist: Wenn man eine virtuelle Vererbung definiert, legt man fest, dass man die Konstruktion der Basis von der zuletzt ableitenden Klasse aus vorgenommen haben will. Immer. Nicht nur dann, wenn es nötig ist. Bei einfacher Vererbung die Konstruktion durch die Basisklasse vornehmen zu lassen würde bedeuten, die Regel für eine Ausnahme zu brechen, nur, um eine Zeile zu sparen. (Dass man trotzdem früher in der Hierarchie den K’tor aufrufen kann, hat den Grund, dass der Compiler nicht sagen kann, ob man die Zwischenstufen der Hierarchie nicht irgendwann instanzieren möchte bzw. wo die Vererbungshierarchie eigentlich zuende ist.)

Weil es einfacher ist: Dadurch hat Vererbung nämlich nur einen zusätzlichen Zustand – virtuell geerbt – statt zweien (virtuell geerbt und virtuell einfach geerbt). Das vereinfacht sowohl den Sprachstandard als auch die Compiler-Implementierung und nicht zuletzt auch die Wartung des Textes (entscheidet man sich, doch noch mehrfach zu erben, muss man nur den Konstruktor der neuen zusätzlichen Basis nachtragen, und nicht wieder den der virtuellen Basis heraussuchen und die Aufgaben, die vorher in der Basis vorgenommen wurden, hochdirigieren).

Alles in allem: Um eine Zeile zu sparen werden keine Regeln gebrochen. Was passiert wenn doch, sieht man an der Pest des explicit-Schlüsselworts.

grid hat geschrieben:Was du hier beschreibst ist das Diamond problem. Wenn man danach sucht findet man einige nützliche Hinweise (z.B. http://en.wikipedia.org/wiki/Diamond_problem), deswegen spare ich mir die Erklärung ;-).

ass die letzte Klasse in der Hierarchy nicht unbedingt etwas von der darunter liegenden Hierarchy wissen muss

Kahino hat geschrieben:

ass die letzte Klasse in der Hierarchy nicht unbedingt etwas von der darunter liegenden Hierarchy wissen muss

Jetzt mal unabhängig von diesem Vererbungsproblem, finde ich diese Aussage ein wenig seltsam.
Du musst nichst von der Implementierung der zu Grunde liegenden Hierarchie wissen,
doch wenn wir von Konstruktoren reden, reden wir von einem Bestandteil der Spezifikation (welche Größtenteils ja von der Programmierung unabhängig ist).
Und Spezifikikationen werden stets mitvererbt.
Das heißt, die Spezifikation der Basis ist neben der Ableitungseigenen, stets auch Spezifikation der Ableitung. Sie darf sich zwar aufweichen, wird vom Grundaufbau jedoch immer mitgetragen. Das heißt, wenn du wissen möchtest was du benötigst, schaust du dir einfach die Basen an von denen du ableitest, keine 10 Ebenen höher oder so.


Ob das nun schick ist oder nicht, dein Problem dabei verstehe ich jetzt irgendwie nicht.
Basen werden nicht prophilaktisch virtuell, das ist eine Designeentscheidung.
Und da Designeentscheidungen eine gewisse Planung voraussetzen, wirst du von vorneherein doch zu mindest abschätzen können ob eine virtuelle Ableitung nötig ist oder nicht. Und wenn sie es ist, wird auf kurz oder lang sowieso eine Mehrfachvererbung entstehen in der diese Klasse merhfach als Basis auftaucht.
Hier sei nochmal erwähnt, das Merhfachvererbung nicht zwangsläufig eine virtuelle Ableitung benötigt.

Ich muss nun durch die virtuelle Vererbung zweimal den gleichen Typ-String übergeben, einmal an den C'tor von A und einmal an den C'tor von B. Das gefährliche daran ist, dass ich A und B verschiedene Typ-Strings übergeben kann (was kein gewolltes Verhalten ist). Der Typ-String-Parameter von B wird komplett überflüssig.

Damit man dort nun eindeutig mit diesen gemeinsamen Basen vorgehen kann, wurde eben entschieden, dass virtuelle Basen prinzipiell zuerst erstellt werden sollten, unabhängig wo sie in der Hierarchie zu finden sind (damit alle von dieser Klasse abhängigen klassen auch ja auf die gleichen Daten zugreifen).
Doch wird durch dieses Verhalten die Kette der Initialisierer gebrochen. Daher entstand noch als Nebeneffekt,
dass alle Initialiserer virtueller Basen in der Hierarchie ignorriert werden und in die klasse verlagert werden,
die inder Hierarchie ganz unten ist. Eben die zuletzt erstellt klasse. DiePerson welche die erstellt ,wird am besten wissen wie die Hierarchie aussehen soll.

Dass die Mehrfachvererbung keine virtuelle Vererbung voraussetzt habe ich selbst erwähnt