Habe folgendes probiert :

Zahlbox1{
public:
Zahlbox1(){;}
Zahlbox1(int in):i(in){;}
int i;
};

Zahlbox2 : public Zahlbox1{
public:
Zahlbox2(){;}
Zahlbox2(long long in):i(in){;}
long long i;
};

Was passiert nun z.B bei :

Zahlbox1 z1 = Zahlbox1();
z1 = Zahlbox2(123456789123456789123456789LL)

Da offenbar Subtying auf den Objekten selber erlaubt ist funktioniert eine
Zuweisung offenbar.Was passiert aber mit dem mit viel größerem Typ überschriebenen Subklassen Attribut? Wird das bei Zuweisung einfach auf die Größe von int verstümmelt und bei Zugriff dann so interpretiert , oder kann es passieren das einfach irgendwelcher anderer Speicher über den für das Objekt reservierten hinaus überschrieben wird ?

Und wie verhält sich das z.B. bei Feldern?
Dachte Folgendes : Ein C-Feld ist doch ein zusammengehöriger sequenzieller Bereich im Speicher , also wird dann vielleicht ein Teil des nächsten im Feld
befindlichen Objekts überschrieben , wenn ich so was zu großes reinpack.

Mit
Zahlbox1 ZF[3];
ZF[0] = Zahlbox2(123456789123456789123456789LL);
ZF[1] = Zahlbox1(8);
ZF[2] = FZahlbox2(123456789123456789123456789LL);
ZF[3] = Zahlbox1(9);

bekomme hier aber die richtige Ausgabe für 8,9 als würden keine Teile von anderen Objekten überschrieben , für die Zahlbox2 Objekte aber irgendwelche
verschiedenen Werte. Wenn ich aber die 2 gleichen Zahlbox2 AttributWerte jetzt aber verschiedene Werte zurückbekomme ist es ja auch kaum möglich das das zu große Attribut zurecht gestutzt wurde.Dennoch wird aber wie gesagt hier scheinbar kein anderes Feldelement(oder Teile davon) überschrieben,da ich 8,9 ja richtig zurück bekomme. Stellt sich für mich also die Frage
was hier genau passiert , ob einfach irgend welcher anderer Speicher überschrieben wird und wie die Speicherung von KlassenInstanzObjekte in einem (seqeunziellen) C-Array eigentlich intern aussieht.Und warum ist Subtyping auf den Objekten selbst überhaupt erlaubt(und nicht nur über Zeiger)? Danke für eure Mühe und eure
Zeit.

Zahlbox1 z1();
/*
Erstellt eine lokale Variable z1. Sobald die Variable ihren Socpe verliert, wird sich von der Runtime gelöscht
*/

z1 = Zahlbox2(123456789123456789123456789LL)
/* z1 erhält ein neues Objekt. Das alte wird automatisch von der
Runtime bereinigt. Vorsicht: Bei new musst du zuerst ein delete ausführen.
Regel:
  - zu jedem new gehört ein delete
  - zu jedem new[] gehört ein delete[]
*/
Zahlbox1 *z = new Zahlbox(2);
delete z;  // Kein delete führt zu einem Speicherleck, da du in der
// nächsten Zeile den Zeiger auf das Objekt verlierst.
z = new Zahlbox2(3L);

Mehr Informationen erhälts du unter:
http://openbook.galileocomputing.de/c_von_a_bis_z/c_013_000.htm#Xxx999328

2. Das Objekt der abgeleiteten Klasse wird zurechgestutzt.

In c++ funktioniert die Polymorphie über Zeiger und Referenzen, d.h. es ist möglich ein Objekt der abgeleiteten Klasse an eine Referenz der Basisklasse zu binden.

Es werden daher der Copy-Konstruktor und der Zuweisungsoperator der Basisklasse verwendet, die du selbst definiert hast bzw. der Compiler definiert hat.

3. Im Konstruktor von Zahlbox2 initialisiert du die Basisklasse nicht, d.h. du gibst dem Basisklassen-i keinen speziellen Wert, daher kommen auch unterschiedliche Zahlen heraus.

P.S.: Du kannst der Basisklasse natürlich auch spezielle Konstruktoren bzw. Zuweisungsoperatoren verpassen, die Objekte der abgeleiteten Klassen akzeptieren, dann wird es allerdings schwierig mit dem Zugriff auf die Member.

1. long long gibt es in Pornos und C99 aber nicht in c++

Was du in deinem Posting als Code-Beispiel zeigst nennt man Slicing, und es ist in C++ erlaubt, weil es nunmal erlaubt ist (weil es sich aus den Regeln für Konvertierung zwischen Referenz-Typen so ergibt).

Und je mehr Fragezeichen und/oder Rufzeichen du an einen Satz dranschreibst... naja, das muss ich jetzt nicht erklären.

Also Nochmal. Du musst dir das nicht so vorstellem, dass bei einer Zuweisung sozusagen der Teil des Speicherbereiches, in welchem das Basisklassen-Objekt liegt 1:1 kopiert wird.

Für folgende Zuweisungen bzw. Initialisierungen

ZF[0] = Zahlbox2(123456789123456789123456789LL); //Zuweisungsoperator
ZF[2] = FZahlbox2(123456789123456789123456789LL);
//..
Zahlbox2 x;
Zahlbox1 y = x; //Copy-Konstruktor

sind Zuweisungsoperator bzw. Copy-Konstruktor der Basisklasse verantwortlich. Es werden also Funktionen aufgerufen.

Diese sehen so aus

class Zahlbox1{
public:
	Zahlbox1(){;}
	Zahlbox1(int in):i(in){;}
	Zahlbox1(const Zahlbox1&);  // Copy-Konstruktor
    Zahlbox1 &operator=(const Zahlbox1&);  //Zuweisungsoperator 
	int i;
};

Und nur weil die Funktionen eine Referenz der Basisklasse erwarten, an die auch Objekte der abgeleiteten Klasse gebunden werden können funktioniert das überhaupt. D.h. es findet ein Typumwandlung statt und das resultierende Objekt hat mit Zahlbox2 nichts mehr zu tun.

123456789123456789123456789LL

Optimist

Übrigens, da du ja bereits mit Java Erfahrung hast, sollte man vielleicht noch bemerken, dass das auch nur funktioniert wenn Zahlbox2 ein "ist ein" Verhältnis zu Zahlbox1 hat. Also, technisch gesprochen, eine public-Vererbung stattfindet.

Zahlbox2 : public Zahlbox1{};

Willst du die Schnittstelle der Basisklasse nicht mehr zur Verfünung stellen, indem du z.B. private oder protectet vererbst

Zahlbox2 : private Zahlbox1{};

dann ist eine Zuweisung bzw. Initialisierung eines Zahlbox1-Objektes mit einem Zahlbox2-Objekt auch nicht mehr möglich.

Tolle Sache.

@hustbaer
Ja, hätte vielleicht mehr darauf achten sollen, was ich da kopiere. Wenigstens habe ich den "Wiedererkennungswert" für den Threadstarter hochgehalten.

... mit einem Zahlbox2-Objekt auch nicht mehr möglich.

in

... mit einem Zahlbox2-Objekt so auch nicht mehr möglich.

Mit der erwähnten Methode der Zahlbox1-Klasse Konstruktor und Zuweisungsoperator zu verpassen, die Zahlbox2-Referenzen erwarten geht es dann natürlich wieder (eingeschränkt).

Hab ich das ungefähr richtig verstanden?

Ich denke schon.

JohnnyDoe schrieb:

Wie sieht das Ganze intern aus bzw. was davon ist auf SICHTBAREN Code abbildbar?

Die Implemtierung des c++-Standards ist selbst nicht standardisiert. Da ist also vieles denkbar. D.h. man kann ohne Informationen des Herstellers gar nicht sagen, was unter der Haube eigentlich passiert.

In der Praxis dürfte jedoch alles ziemlich nahe an Stroustrups Modell sein. Dort werden die nichtstatischen Member eines Objekts zusammen mit den eventuell vorhandenen Zeigern auf sog. "Virtual Tables" in einem Speicherbereich zusammengesetzt. Innerhalb dieses Bereichs kann dann direkt adressiert werden (über ein Offset).

Der Speicherbereich eines Objekts der abgeleiteten Klasse enthält dann die Member aus der Basisklasse und daran angehängt, die Member, die durch die abgeleitete Klasse zusätzlich definiert werden. Je nachdem, wie deine Klassenhierarchie aussieht (Mehrfachverbung, virtuelle Funktionen) sind dann noch keiner, einer oder mehrere dieser Zeiger auf die jeweilige Virtual Table dabei. Es wird ebenfalls direkt adressiert.

Nur die virtuelle Basisklasse bei der virtuellen Vererbung bildet da ein Ausnahme. Auf die muss indirekt zugegriffen werden. Da gibt es dann auch wieder verschiedene Möglichkeiten das zu realisieren.

Das ist aber alles nicht in 3 oder 4 Worten erklärt. Vor allem die Vor- und Nachteile einer bestimmten Vorgehensweise. Ich kenne dummerweise auch kein Tutorial oder Link in welchem man sich schnell eine Übersicht verschaffen könnte. Vielleicht hilft einer der Kollegen aus.

Oder du gibst dir die entsprechende Literatur. Lippman hat da ein ganzes Buch dazu geschrieben und das eine oder andere Paper zu dem Thema geistert wohl auch herum. Wie gesagt, vielleicht kennt ein anderer Forenteilnehmer eine gute Quelle.