Czy to użycie std :: make_unique prowadzi do nieunikalnych wskaźników?

Question

Załóżmy, że mam następujący kod w C++:

#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; 
} 

Jak rozumiem, unikalne wskaźniki są stosowane w celu zagwarantowania, że ​​środki nie są wspólne. Ale w tym przypadku zarówno p1, jak i p2 wskazują na to samo wystąpienie some.

Prosimy o przedstawienie sytuacji.

Answer 1

Oni nie wskazują na samym zasobu, że każdy punkt na inny z kopią to. Można zilustrować go usuwając konstruktor kopiujący zobaczyć błąd:

#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 tworzy obiekty, wywołując konstruktor z określonymi argumentami.

Podałeś Some& jako parametr, a tutaj skopiowano konstruktora i skonstruowano nowy obiekt.

Tak, P1 i P2 są absolutnie różne wskaźniki 2, ale zbudowane z tego samego przedmiotu, używając kopii konstruktora

Answer 3

przetestować, czy dwa wskaźniki wskazują na tej samej instancji obiektu, należy porównać lokalizacje one wskazują, zamiast zmiennych składowych obiektu:

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

który pokaże, że rzeczywiście robią nie punkt do tej samej instancji.

Uzupełnienie: Jak podkreślił Remy Lebeau, ponieważ C++ 11 wskazane jest, aby korzystać z funkcji std::addressof do tego celu, który uzyskuje rzeczywisty adres obiektu, nawet jeśli operator & jest przeciążony:

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; 
} 

wyjściowa:

5 5 
42 5