Wann führt das Aufrufen einer Mitgliedsfunktion für eine Nullinstanz zu einem undefinierten Verhalten?

Betrachten Sie den folgenden Code:

#include <iostream>

struct foo
{
    // (a):
    void bar() { std::cout << "gman was here" << std::endl; }

    // (b):
    void baz() { x = 5; }

    int x;
};

int main()
{
    foo* f = 0;

    f->bar(); // (a)
    f->baz(); // (b)
}

Wir erwarten (b)einen Absturz, da es kein entsprechendes Mitglied xfür den Nullzeiger gibt. In der Praxis (a)stürzt nicht ab, da der thisZeiger nie verwendet wird.

Da (b)der thisZeiger ( (*this).x = 5;) dereferenziert und thisnull ist, gibt das Programm ein undefiniertes Verhalten ein, da das Dereferenzieren von null immer als undefiniertes Verhalten bezeichnet wird.

Führt (a)zu undefiniertem Verhalten? Was ist, wenn beide Funktionen (und x) statisch sind?

Beides (a)und (b)führen zu undefiniertem Verhalten. Es ist immer undefiniertes Verhalten, eine Mitgliedsfunktion über einen Nullzeiger aufzurufen. Wenn die Funktion statisch ist, ist sie auch technisch undefiniert, aber es gibt einige Streitigkeiten.

Das erste, was zu verstehen ist, ist, warum es undefiniertes Verhalten ist, einen Nullzeiger zu dereferenzieren. In C ++ 03 gibt es hier tatsächlich ein bisschen Mehrdeutigkeit.

Obwohl "das Dereferenzieren eines Nullzeigers zu undefiniertem Verhalten führt" in den Anmerkungen sowohl in §1.9 / 4 als auch in §8.3.2 / 4 erwähnt wird, wird dies niemals explizit angegeben. (Notizen sind nicht normativ.)

Man kann jedoch versuchen, es aus §3.10 / 2 abzuleiten:

Ein Wert bezieht sich auf ein Objekt oder eine Funktion.

Bei der Dereferenzierung ist das Ergebnis ein Wert. Ein Nullzeiger nicht auf ein Objekt. Wenn wir also den Wert l verwenden, haben wir ein undefiniertes Verhalten. Das Problem ist, dass der vorherige Satz nie angegeben wird. Was bedeutet es also, den Wert zu "verwenden"? Generieren Sie es einfach überhaupt oder verwenden Sie es im formaleren Sinne, um eine Wert-zu-Wert-Konvertierung durchzuführen?

Unabhängig davon kann es definitiv nicht in einen Wert umgewandelt werden (§4.1 / 1):

Wenn das Objekt, auf das sich der Wert bezieht, kein Objekt vom Typ T und kein Objekt von einem von T abgeleiteten Typ ist oder wenn das Objekt nicht initialisiert ist, hat ein Programm, das diese Konvertierung erfordert, ein undefiniertes Verhalten.

Hier ist es definitiv undefiniertes Verhalten.

Die Mehrdeutigkeit ergibt sich daraus, ob es sich um ein undefiniertes Verhalten zur Zurückhaltung handelt oder nicht, aber den Wert eines ungültigen Zeigers nicht verwendet (dh einen l-Wert erhalten, ihn aber nicht in einen r-Wert konvertieren). Wenn nicht, dann int *i = 0; *i; &(*i);ist genau definiert. Dies ist ein aktives Problem .

Wir haben also eine strikte Ansicht "Dereferenzieren eines Nullzeigers, Erhalten eines undefinierten Verhaltens" und eine schwache Ansicht "Verwenden eines dereferenzierten Nullzeigers, Erhalten eines undefinierten Verhaltens".

Nun betrachten wir die Frage.

Ja, (a)führt zu undefiniertem Verhalten. In der Tat, wenn thisdann null ist das Ergebnis unabhängig vom Inhalt der Funktion undefiniert.

Dies folgt aus §5.2.5 / 3:

Wenn E1der Typ "Zeiger auf Klasse X" ist, wird der Ausdruck E1->E2in die entsprechende Form konvertiert(*(E1)).E2;

*(E1) wird zu undefiniertem Verhalten mit einer strengen Interpretation führen, und .E2 konvertiert es in einen r-Wert, wodurch es für die schwache Interpretation zu undefiniertem Verhalten wird.

Daraus folgt auch, dass es sich um ein undefiniertes Verhalten direkt aus (§9.3.1 / 1) handelt:

Wenn eine nicht statische Elementfunktion einer Klasse X für ein Objekt aufgerufen wird, das nicht vom Typ X oder von X abgeleitet ist, ist das Verhalten undefiniert.

Bei statischen Funktionen macht die strikte gegenüber der schwachen Interpretation den Unterschied. Genau genommen ist es undefiniert:

Auf ein statisches Element kann unter Verwendung der Klassenmitgliedszugriffssyntax verwiesen werden. In diesem Fall wird der Objektausdruck ausgewertet.

Das heißt, es wird so ausgewertet, als wäre es nicht statisch, und wir dereferenzieren erneut einen Nullzeiger mit (*(E1)).E2.

Da dies E1jedoch nicht in einem statischen Elementfunktionsaufruf verwendet wird, ist der Aufruf gut definiert, wenn wir die schwache Interpretation verwenden. *(E1)ergibt sich ein lWert, die statische Funktion wird aufgelöst,*(E1) verworfen und die Funktion aufgerufen. Es gibt keine Konvertierung von lWert in rWert, daher gibt es kein undefiniertes Verhalten.

In C ++ 0x bleibt ab n3126 die Mehrdeutigkeit bestehen. Seien Sie vorerst sicher: Verwenden Sie die strenge Interpretation.

Offensichtlich bedeutet undefiniert, dass es nicht definiert ist , aber manchmal kann es vorhersehbar sein. Die Informationen, die ich bereitstellen werde, sollten für den Arbeitscode niemals verwendet werden, da sie sicherlich nicht garantiert sind, aber beim Debuggen nützlich sein können.

Sie könnten denken, dass das Aufrufen einer Funktion für einen Objektzeiger den Zeiger dereferenziert und UB verursacht. In der Praxis , wenn die Funktion nicht virtuell ist, hat sich der Compiler es zu einem einfachen Funktionsaufruf übergeben den Zeiger als ersten Parameter konvertiert diese , die dereferenzieren Umgehung und eine Zeitbombe für die gerufene Memberfunktion zu schaffen. Wenn die Member-Funktion keine Member-Variablen oder virtuellen Funktionen referenziert, ist sie möglicherweise tatsächlich fehlerfrei erfolgreich. Denken Sie daran, dass Erfolg in das Universum von "undefiniert" fällt!

Die MFC-Funktion GetSafeHwnd von Microsoft basiert tatsächlich auf diesem Verhalten. Ich weiß nicht, was sie geraucht haben.

Wenn Sie eine virtuelle Funktion aufrufen, muss der Zeiger dereferenziert werden, um zur vtable zu gelangen, und Sie werden mit Sicherheit UB erhalten (wahrscheinlich ein Absturz, aber denken Sie daran, dass es keine Garantien gibt).