C++Talk.NET

Thomas Mang · Guest

Ich habe beim Nachforschen, ob das was ich machen möchte OK ist, eine
bemerkenswerte Entdeckung gemacht:

Man nehme eine Klasse Foo, Bar, sowie eine Funktion Crash:

class Bar;

class Foo
{
public:
Foo(Bar &);
};

void Crash(Bar &);

class Bar
{
public:
Bar() : f(*this) {}
~Bar() {Crash(*this);}
private:
Foo f;
};

Ist so wie hier präsentiert natürlich nur aufs wichtigste beschränkt.

Hier worum es geht:
im Bar-Konstruktor wir das member f vom Typ Foo mit *this initialisiert. Das
Argument *this hat als zugehörigen Parameter ein Bar&. Wenn ich den Standard
richtig lese, ist das undefiniertes Verhalten.
Gemäß 8.5.3/1 muss eine Referenz mit einem Objekt initialisiert werden (die
anderen Möglichkeiten scheiden hier aus). Gemäß 3.8.1 beginnt ein Objekt
aber erst zu leben, wenn der Konstruktoraufruf _beendet_ ist. Im obigen
Schnippsel sind wir aber gerade dabei, den Konstruktor auszuführen. Also
wird die Referenz mit einem nicht-existierenden Objekt initialisiert.

Im Destruktor passiert dasselbe:
Gemäß 3.8.1 ist das Bar-Objekt schon tot, da der Destruktor begonnen hat,
und es wird ebenfalls eine Referenz mit einem toten Ding initialisiert.

Ich lese 8.5.3/1 so, dass das bereits UB ist, egal was dann die aufgerufenen
Funktionen machen (z.B. r-value Konvertierung).

Wenn man das ganze aber in pointer-Form schreibt, scheint alles OK zu sein:

class Bar;

class Foo
{
public:
Foo(Bar *);
};

void NoCrash(Bar *);

class Bar
{
public:
Bar() : f(this) {}
~Bar() {NoCrash(this);}
private:
Foo f;
};

Referenzen kommen hier nicht mehr vor, dafür der this-pointer.

In 12.7/2 steht, dass Formen des this-pointers legal ist, solange entweder
der Konstruktor _begonnen_ hat, oder der Destruktor _noch nicht beendet_
hat.. Beides ist hier der Fall.

Demnach macht es einen großen Unterschied, ob ich mein Bar-Objekt per
Referenz oder per Zeiger übergebe !

Gerade dass mit dem Destruktor macht mir sorgen, ich habe schon mehr als
einmal gesehen, dass sich Objekte woanders abmelden, und sich per Referenz
übergeben (u.a. habe ich soetwas selber schon mal gemacht.....).

Aber auch die Sache mit dem Zeiger dürfte nicht ganz harmlos sein. Hier ein
Bsp., was meine ganzen Recherchen erst gestartet hat, weil ich ein
schlechtes Bauchgefühl hatte, und anscheinend damit richtig lag:

class Bar;

class Holder
{
public:
Holder(Bar*);
};

class Bar
{
public:
Bar(Holder h) : h_(h) {}
private:
Holder h_;
};

class BarDerived : public Bar
{
public:
BarDerived() : Bar(Holder(this)) {}
};

Hier übergibt BarDerived den this-pointer an Holder. Und Rums. Denn der
BarDerived* wird in ein Bar* konvertiert, aber das Bar-subobject hat noch
nicht mit dem Konstruktor begonnen. Also findet eine ungültige
Zeigerkonvertierung statt. Kreire ich hingegen Bar per Standardkonstruktor,
und rufe dann im Konstruktorrumpf eine assignment-Funktion auf, die das
member h_ mit eime Holder belegt, ist alles in Ordnung - weill Bar dann
konstruiert wurde, und die Konvertierung BarDerived* -> Bar* in Ordnung ist.

Ist meine Interpretation der Lage richtig?
Also Code umschreiben.....

Thomas

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Bob Hairgrove · Guest

On Sat, 15 Oct 2005 23:32:40 +0200, "Thomas Mang"
<a9804814 (AT) unet (DOT) univie.ac.at> wrote:

James Kanze · Guest

Thomas Mang wrote:

Thomas Mang · Guest

"Bob Hairgrove" <invalid (AT) bigfoot (DOT) com> schrieb im Newsbeitrag
news:0m33l1dqgel7m6uh23tkhib7foc1997m2c (AT) 4ax (DOT) com...