Wie verhindere ich den Speicherverlust von unique_ptr

Question

Dieser Code führt zu einem Speicherverlust, weil rA als ungültig initialisiert wird, wenn es erstellt wird. Wann kann ich dieses Problem beheben?

Verwenden Sie shared_ptr oder hoffe auf zukünftige Compiler-Versionen, um diesen schlechten Code zu fangen?

#include <memory> 
using namespace std; 

struct A {}; 
void use(const A& a) {}; 

unique_ptr<A> foo() 
{ 
    unique_ptr<A> pa(new A()); 
    return pa; 
} 

int main() 
{ 
    const A& rA = *foo(); // rA is unusable, initialized with invalid reference (invalidated by destruction of temporary unique_ptr returned from foo) 
    use(rA); 
} 

Answer 1

Rewrite Ihre main als:

int main() 
{ 
    auto a = foo(); 

    use(*a); 
} 

Als Nebenwirkung würde ich umschreiben foo wie:

std::unique_ptr<A> foo() 
{ 
    return std::make_unique<A>(); 
} 

Answer 2

Wenn Sie Objekte zurück von Wert Sie eine temporäre zurückgeben, wird zerstört werden sofort, es sei denn, es wird von der Seite des Anrufers kopiert oder an eine Variable gebunden.

Was Sie falsch machen, ist das Binden eines Verweises auf etwas, das das zurückgegebene temporäre Objekt enthält und nicht das zurückgegebene Objekt selbst. Zu dem Zeitpunkt, an dem Sie auf das Objekt zugreifen, das Sie gebunden haben, wurde ein Verweis darauf vom Destruktor des temporären Objekts gelöscht, wenn es zerstört wurde.

Um zu zeigen, was man falsch machen ein äquivalentes Beispiel unter Verwendung eines std::vector und Bindung einen Verweis auf eines ihrer Elemente Ich habe geschrieben:

void use(const int& a) {} 

std::vector<int> foo() 
{ 
    return {1, 2, 3}; 
} 

int main() 
{ 
    const int& rA = foo()[0]; // bind to an element 
    // the vector itself is destroyed by the time we get here 

    use(rA); // whoops using a reference to an element from a destroyed vector 
}