2016-10-07 3 views
0

Ich bin ein wenig verwirrt über Operator neu zu laden und zu löschen. schrieb ich einige Test:C++ - Überladung Operator neu

#include <iostream> 

using namespace std; 

class Test 
{ 
    public : 

    Test() 
    { 
     cout << "Test - ctor" <<endl; 
    } 

    ~Test() 
    { 
     cout << "Test - dtor" <<endl; 
    } 

    Test(const Test& t) 
    { 
     cout << "Test - copy ctor" <<endl; 
    } 

    Test& operator = (const Test& t) 
    { 
     cout << "Test - assiment operator" <<endl; 
    } 

    void* operator new(size_t size) 
    { 
     cout << "Test - operator new" <<endl; 
     return NULL; 
    } 

    void print() 
    { 
     cout << "print" << endl; 
    } 
}; 


int main() 
{ 
    Test* t = new Test(); 
    t->print(); 
    return 0; 
} 

Und der Ausgang ist:

Test - operator new                                             
Test - ctor                                               
print 

Nun, wenn ich „NULL“ aus den „neuen“ zurückzukehren, warum mein Programm nicht abstürzen, wenn ich Druck nennen Funktion? danke.

+0

die nichts mit der Überlastung zu tun hat, ist es regelmäßig nicht definiertes Verhalten ist. Versuchen Sie 'Test * t = nullptr; t-> print(); 'und sehen, was passiert (oder nicht). – molbdnilo

+0

UB ist wie UB tut. – George

Antwort

2

Weil print() eigentlich nichts von seiner Klasse Test benötigt. Es druckt nur eine Nachricht an stdout. Denken Sie daran, dass t->print(); ist die gleiche wie print(t);, ist Ihre Funktion Unterschrift tatsächlich:

void print(Test* t); 

aber das ist alles vom Compiler für Sie erledigt.

t wird einfach nicht in der Methode verwendet und Sie sind also (un) glücklich, weil es läuft. Dies ist jedoch immer noch nur ein undefiniertes Verhalten.

Wenn Sie unbedingt wollen Dinge Absturz und brennen dann ändern Sie Ihre Klasse ein wenig sehen:

class Test 
{ 
    public : 

    Test() : x(0) 
    { 
     cout << "Test - ctor" <<endl; 
    } 

    ~Test() 
    { 
     cout << "Test - dtor" <<endl; 
    } 

    Test(const Test& t) 
    { 
     cout << "Test - copy ctor" <<endl; 
    } 

    Test& operator = (const Test& t) 
    { 
     cout << "Test - assiment operator" <<endl; 
    } 

    void* operator new(size_t size) 
    { 
     cout << "Test - operator new" <<endl; 
     return NULL; 
    } 

    void print() 
    { 
     cout << "print" << x << endl; 
    } 

private: 
    int x; 
}; 
+0

Danke. Jetzt verstehe ich. –

1

Dieses spezifische Phänomen hat nichts zu tun mit Ihrer operator new Funktion.

Das Verhalten beim Aufrufen einer Elementfunktion durch einen Nullzeiger ist undefined. Ihr Ergebnis ist eine Manifestation dieses undefinierten Verhaltens.

Es passiert zufällig in Ihrem speziellen Fall (möglicherweise weil Ihre Klasse nur eine Tasche von Funktionen ist).

(Heutzutage ist es eine gute Idee, nullptr anstatt der altmodischen und nicht absolut korrekt NULL zu verwenden.)

+0

Dies ist eine viel bessere Antwort als die angenommene, die voller falscher Tatsachen und schlechter Ratschläge ist. –

+0

@MikeVine Ich sehe keinen "Ratschlag" in meiner Antwort. Wenn Sie mit etwas in der Antwort nicht einverstanden sind, hinterlassen Sie einen Kommentar. –

+1

@GillBates _... Ihre Funktionen Signatur ist eigentlich ..._ Nein ist es nicht. _Wenn du Dinge crashen und verbrennen sehen willst_ Nein, sie werden nicht. Undefinierter Behavoir ist undefiniert. Entweder das Original oder Ihr neues kann abstürzen oder nicht, abhängig von vielen verschiedenen Dingen einschließlich möglicherweise der Phase des Mondes. Sein _Undefined_. Diese Antwort sagt das. Undefiniert ist genau das. Es ist fast nie das Richtige herauszufinden, warum nach UB etwas passiert. –