Zugreifen auf Klassenmitglieder auf einen NULL-Zeiger

Ich habe mit C++ experimentiert und fand den folgenden Code sehr seltsam.

class Foo{
public:
    virtual void say_virtual_hi(){
        std::cout << "Virtual Hi";
    }

    void say_hi()
    {
        std::cout << "Hi";
    }
};

int main(int argc, char** argv)
{
    Foo* foo = 0;
    foo->say_hi(); // works well
    foo->say_virtual_hi(); // will crash the app
    return 0;
}

Ich weiß, dass der virtuelle Methodenaufruf abstürzt, weil er eine vtable-Suche erfordert und nur mit gültigen Objekten arbeiten kann.

Ich habe folgende Fragen

1. Wie funktioniert die nicht virtuelle Methode say_hi Arbeit an einem NULL-Zeiger?
2. Woher kommt das Objekt foo zugeteilt werden?

Irgendwelche Gedanken?

Das Objekt foo ist eine lokale Variable vom Typ Foo*. Diese Variable wird wahrscheinlich auf dem Stack für die zugewiesen main Funktion, genau wie jede andere lokale Variable. Aber die Wert darin gespeichert foo ist ein Nullzeiger. Es zeigt nirgendwo hin. Es gibt keine Instanz des Typs Foo überall vertreten.

Um eine virtuelle Funktion aufzurufen, muss der Aufrufer wissen, auf welchem ​​Objekt die Funktion aufgerufen wird. Das liegt daran, dass das Objekt selbst angibt, welche Funktion wirklich aufgerufen werden soll. (Das wird häufig implementiert, indem dem Objekt ein Zeiger auf eine vtable, eine Liste von Funktionszeigern, gegeben wird und der Aufrufer einfach weiß, dass er die erste Funktion auf der Liste aufrufen soll, ohne im Voraus zu wissen, wohin dieser Zeiger zeigt.)

Aber um eine nicht-virtuelle Funktion aufzurufen, muss der Aufrufer das alles nicht wissen. Der Compiler weiß genau, welche Funktion aufgerufen wird, also kann er eine generieren CALL Maschinencode-Anweisung, um direkt zur gewünschten Funktion zu gelangen. Es übergibt einfach einen Zeiger auf das Objekt, für das die Funktion aufgerufen wurde, als versteckten Parameter an die Funktion. Mit anderen Worten, der Compiler übersetzt Ihren Funktionsaufruf in Folgendes:

void Foo_say_hi(Foo* this);

Foo_say_hi(foo);

Da die Implementierung dieser Funktion nun niemals auf irgendwelche Mitglieder des Objekts verweist, auf die sie zeigt this -Argument weichen Sie effektiv der Kugel aus, einen Nullzeiger zu dereferenzieren, da Sie niemals einen dereferenzieren.

Formell anrufen irgendein Funktion – auch eine nicht virtuelle – auf einem Nullzeiger ist ein undefiniertes Verhalten. Eines der zulässigen Ergebnisse von undefiniertem Verhalten ist, dass Ihr Code anscheinend genau so ausgeführt wird, wie Sie es beabsichtigt haben. Du Sie sollten sich nicht darauf verlassen, obwohl Sie manchmal Bibliotheken von Ihrem Compiler-Anbieter finden werden tun darauf verlassen. Aber der Compiler-Anbieter hat den Vorteil, dass er weitere Definitionen zu ansonsten undefiniertem Verhalten hinzufügen kann. Mach es nicht selbst.

Das say_hi() Die Member-Funktion wird normalerweise vom Compiler als implementiert

void say_hi(Foo *this);

Da Sie auf keine Mitglieder zugreifen, ist Ihr Aufruf erfolgreich (obwohl Sie gemäß dem Standard undefiniertes Verhalten eingeben).

Foo wird gar nicht zugeteilt.

Das Dereferenzieren eines NULL-Zeigers verursacht “undefiniertes Verhalten”. Dies bedeutet, dass alles passieren kann – Ihr Code kann sogar scheinbar richtig funktionieren. Sie dürfen sich jedoch nicht darauf verlassen – wenn Sie denselben Code auf einer anderen Plattform (oder möglicherweise sogar auf derselben Plattform) ausführen, wird er wahrscheinlich abstürzen.

In Ihrem Code gibt es kein Foo-Objekt, nur einen Zeiger, der mit dem Wert NULL initialisiert wird.

Es ist ein undefiniertes Verhalten, aber die meisten Compiler generieren Anweisungen, die diese Situation korrekt handhaben, wenn Sie weder auf Member-Variablen noch auf die virtuelle Tabelle zugreifen.

Sehen wir uns die von Visual Studio generierte Disassemblierung an, um zu verstehen, was passiert:

   Foo* foo = 0;
004114BE  mov         dword ptr [foo],0 
    foo->say_hi(); // works well
004114C5  mov         ecx,dword ptr [foo] 
004114C8  call        Foo::say_hi (411091h) 
    foo->say_virtual_hi(); // will crash the app
004114CD  mov         eax,dword ptr [foo] 
004114D0  mov         edx,dword ptr [eax] 
004114D2  mov         esi,esp 
004114D4  mov         ecx,dword ptr [foo] 
004114D7  mov         eax,dword ptr [edx] 
004114D9  call        eax  

Wie du sehen kannst Foo:say_hi wird als normale Funktion aufgerufen, aber mit this in dem ecx registrieren. Vereinfacht kann man davon ausgehen this wird als impliziter Parameter übergeben, der in Ihrem Beispiel nie verwendet wird.
Aber im zweiten Fall muss aufgrund der virtuellen Tabelle die Adresse der Funktion berechnet werden – dazu muss die Adresse von foo gültig ist und einen Absturz verursacht.

Es ist wichtig, das zu erkennen beide Aufrufe erzeugen ein undefiniertes Verhalten, und dieses Verhalten kann sich auf unerwartete Weise manifestieren. Auch wenn der Anruf erscheint zu funktionieren, kann es sein, dass es ein Minenfeld legt.

Betrachten Sie diese kleine Änderung an Ihrem Beispiel:

Foo* foo = 0;
foo->say_hi(); // appears to work
if (foo != 0)
    foo->say_virtual_hi(); // why does it still crash?

Seit dem ersten Anruf an foo aktiviert undefiniertes Verhalten, wenn foo null ist, kann der Compiler jetzt davon ausgehen foo ist nicht Null. Das macht die if (foo != 0) überflüssig, und der Compiler kann es optimieren! Sie könnten denken, dass dies eine sehr sinnlose Optimierung ist, aber die Compiler-Autoren sind sehr aggressiv geworden, und so etwas ist im tatsächlichen Code passiert.

a) Es funktioniert, weil es nichts durch den impliziten “this”-Zeiger dereferenziert. Sobald Sie das tun, boom. Ich bin mir nicht 100% sicher, aber ich denke, dass Nullzeiger-Dereferenzierungen von RW durchgeführt werden, das die ersten 1 KB Speicherplatz schützt. Daher besteht eine geringe Chance, dass die Nullreferenzierung nicht abgefangen wird, wenn Sie sie nur über die 1-KB-Zeile hinaus dereferenzieren (dh eine Instanzvariable das würde sehr weit verteilt werden, wie:

 class A {
     char foo[2048];
     int i;
 }

dann wäre a->i möglicherweise nicht erfasst, wenn A null ist.

b) Nirgendwo haben Sie nur einen Zeiger deklariert, der auf dem Stack von main(): liegt.

Der Aufruf von say_hi ist statisch gebunden. Der Computer führt also eigentlich nur einen Standardaufruf einer Funktion aus. Die Funktion verwendet keine Felder, daher gibt es kein Problem.

Der Aufruf von virtual_say_hi ist dynamisch gebunden, also geht der Prozessor zum virtuellen Tisch, und da es dort keinen virtuellen Tisch gibt, springt er irgendwo hin und bringt das Programm zum Absturz.