Führt diese Verwendung von std :: make_unique zu nicht eindeutigen Zeigern?

Question

Angenommen, ich den folgenden Code in C++ haben:

#include <memory> 
#include <iostream> 

struct Some { 
     Some(int _a) : a(_a) {} 
     int a; 
}; 

int main() { 
     Some some(5); 

     std::unique_ptr<Some> p1 = std::make_unique<Some>(some); 
     std::unique_ptr<Some> p2 = std::make_unique<Some>(some); 

     std::cout << p1->a << " " << p2->a << std::endl; 
     return 0; 
} 

Wie ich verstehe, sind eindeutige Hinweise verwendet, um sicherzustellen, dass Ressourcen nicht gemeinsam genutzt werden. Aber in diesem Fall verweisen sowohl p1 als auch p2 auf dieselbe Instanz some.

Bitte enthüllen Sie die Situation.

Answer 1

Sie verweisen nicht auf die gleiche Ressource, sie zeigen jeweils auf eine andere Kopie von es. Sie können es veranschaulichen, indem Sie den Copykonstruktor Löschen der Fehler zu sehen:

#include <memory> 
#include <iostream> 

struct Some { 
     Some(int _a) : a(_a) {} 
     Some(Some const&) = delete; 
     int a; 
}; 

int main() { 
     Some some(5); 

     std::unique_ptr<Some> p1 = std::make_unique<Some>(some); //error here 
     std::unique_ptr<Some> p2 = std::make_unique<Some>(some); 

     std::cout << p1->a << " " << p2->a << std::endl; 
     return 0; 
} 

Answer 2

std::make_unique erstellt Objekte, Aufrufkonstruktor mit angegebenen Argumenten.

Sie haben Some& als Parameter übergeben, und hier wurde der Kopierkonstruktor aufgerufen und ein neues Objekt erstellt.

Also, P1 und P2 sind zwei absolut unterschiedliche Zeiger, aber von demselben Objekt aufgebaut, Copykonstruktor mit

Answer 3

Um zu testen, ob zwei Zeiger auf das gleiche Objekt Instanz zeigen, sollten Sie die Standorte weisen sie auf, anstelle der Objektelementvariablen vergleichen:

std::cout << &(*p1) << " " << &(*p2) << std::endl; 

die zeigen, dass sie tatsächlich auf der gleichen Instanz nicht Punkt tun.

NACHTRAG: Wie Remy Lebeau wies darauf hin, seit 11 C++ ist es ratsam, die std::addressof Funktion für diesen Zweck zu verwenden, die die tatsächliche Adresse eines Objekts erhält, selbst wenn die & Betreiber überlastet sind:

std::cout << std::addressof(*p1) << " " << std::addressof(*p2) << std::endl; 

Answer 4

both p1 and p2 point to the same instance some

No, they don't.

#include <memory> 
#include <iostream> 

struct Some { 
     Some(int _a) : a(_a) {} 
     int a; 
}; 

int main() { 
     Some some(5); 

     std::unique_ptr<Some> p1 = std::make_unique<Some>(some); 
     std::unique_ptr<Some> p2 = std::make_unique<Some>(some); 

     std::cout << p1->a << " " << p2->a << std::endl; 
     p1->a = 42; 
     std::cout << p1->a << " " << p2->a << std::endl; 
     return 0; 
} 

output:

0.123.