können Sie mir sagen, warum stürzt dieser Code ab?

Question

Also bin ich neugierig auf den Grund, warum der folgende Code abstürzt. Ich schätze die Hilfe.

#include <iostream> 
using namespace std; 

class temp 
{  
    public: 

    temp(int i) 
    { 
     intPtr = new int(i); 
    } 

    ~temp() 
    { 
     delete intPtr; 
    } 

    private: 
    int* intPtr; 
}; 

void f (temp fInput) 
{ 
    cout << "f called" << endl; 
} 

int main() 
{ 
    temp x = 2; 
    f(x); 
    return 0; 
} 

Answer 1

Der Zeiger kopiert wird, wenn x (impliziten Copykonstruktor) übergeben wird und der Destruktor bezeichnet wird zweimal (bevor die Funktion zurückkehrt und vor dem Haupt Returns), so wird der Speicher zweimal gelöscht.

Verwenden std::shared_ptr<int> hier stattdessen anstelle eines rohen int Zeiger (vorausgesetzt, Sie wollen das gleiche Verhalten sein, das heißt die gleiche int von beiden temp s verweisen, andernfalls den Kopierkonstruktor implementieren, bewegen Konstruktor und Zuweisungsoperator selbst).

#include <memory> 

class temp {  
public: 
    temp(int i) : intPtr(std::make_shared<int>(i)) { 

    } 

private: 
    std::shared_ptr<int> intPtr; // reference counting ftw 
}; 

Answer 2

Der Absturz tritt auf, weil Sie x passieren.

Nach dem Umfang der f Funktion wird x 's Destruktur aufgerufen und intPtr gelöscht.

Das wird jedoch Speicher löschen, der immer noch in Bereich für main ist. Daher wird nach dem Aufruf von return 0 versucht, Speicher zu löschen, der bereits vorhanden ist, während Sie zweimal auf demselben Zeiger löschen.

diesen Fehler zu beheben, ändern

void f (temp fInput) 

zu

void f (const temp& fInput) 

Alternativ Sie in mit einem std::shared_ptr aussehen könnte.

Answer 3

Sie verletzen The Rule of Three

Sie pflegen einen Zeiger Mitglied und Sie übergeben eine Kopie des Objekts an die Funktion f. Also, das Endergebnis ist, dass Sie delete zweimal auf dem gleichen Zeiger aufrufen.

Answer 4

Das Problem, das Sie hier treffen, ist ein doppeltes Löschen. Da Sie hier keine Kopierkonstruktoren definiert haben, macht C++ das gerne für Sie. Die Implementierung führt dies durch Ausführen einer flachen Kopie aller Inhalte durch.

f(x); 

Diese Linie funktioniert, indem eine Kopie x erstellen und zu f vorbei. An diesem Punkt gibt es 2 temp Instanzen, die ein einzelnes Mitglied besitzen. Beide Instanzen werden diesen Zeiger löschen, und das ist wahrscheinlich, was Ihren Absturz verursacht.

um dieses Problem zu umgehen Sie eine Reihe von Maßnahmen ergreifen können,

1. einen Zeigertyp für den Austausch wie shared_ptr<T>
2. , die durch ref übergeben werden zwingt die Instanz erstellen unkündbare Copykonstruktor gemeint Verwenden

Ein Beispiel # 2 ist

class temp { 
    temp(const temp& other); 
    temp& operator=(const temp& other); 
public: 
    // Same 
}; 

Jetzt wird die Zeile f(x) einfach nicht kompiliert, da sie nicht auf den notwendigen Kopierkonstruktor zugreifen kann. Es zwingt es stattdessen, f neu zu definieren, um eine Kopie zu verhindern.

void f(const temp& fInput) { 
    ... 
}