Różnice między std :: make_unique i std :: unique_ptr z new

Czy std::make_uniquema jakieś korzyści związane z wydajnością std::make_shared?

W porównaniu z tworzeniem ręcznym std::unique_ptr:

std::make_unique<int>(1);         // vs
std::unique_ptr<int>(new int(1));

Motywacja make_uniquejest przede wszystkim dwojaka:

• make_uniquejest bezpieczny do tworzenia tymczasowych, natomiast przy jawnym użyciu newnależy pamiętać o zasadzie nieużywania nienazwanych tymczasowych.

  foo(make_unique<T>(), make_unique<U>()); // exception safe
  
  foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*

• Dodanie make_uniquewreszcie oznacza, że ​​możemy powiedzieć ludziom, aby „nigdy” nie używali, newa nie poprzednią regułę, aby „nigdy” nie używali, newz wyjątkiem sytuacji, gdy zrobisz unique_ptr".

Jest też trzeci powód:

• make_uniquenie wymaga nadmiarowego użycia typu. unique_ptr<T>(new T())->make_unique<T>()

Żaden z powodów nie wiąże się z poprawą wydajności czasu wykonywania w sposób, w jaki używa się make_sharedtego (ze względu na unikanie drugiej alokacji, kosztem potencjalnie wyższego szczytowego wykorzystania pamięci).

* Oczekuje się, że C ++ 17 będzie zawierał zmianę reguły, która oznacza, że ​​nie jest to już niebezpieczne. Zobacz dokumenty komisji C ++ P0400R0 i P0145R3 .

std::make_uniquei std::make_sharedsą z dwóch powodów:

1. Aby nie trzeba było jawnie wymieniać argumentów typu szablonu.
2. Dodatkowe bezpieczeństwo wyjątków dotyczące używania std::unique_ptrlub std::shared_ptrkonstruktorów. (Zobacz sekcję Uwagi tutaj ).

Tak naprawdę nie chodzi o wydajność czasu wykonywania. Jest trochę o bloku kontrolnym i Tprzydzielaniu wszystkiego naraz, ale myślę, że to bardziej bonus, a mniej motywacja do istnienia tych funkcji.

Powód, dla którego musiałbyś użyć std::unique_ptr(new A())lub std::shared_ptr(new A())bezpośrednio zamiast std::make_*()nie jest w stanie uzyskać dostępu do konstruktora klasy Apoza bieżącym zakresem.

Rozważ wywołanie funkcji

void function(std::unique_ptr<A>(new A()), std::unique_ptr<B>(new B())) { ... }

Załóżmy, że new się A()powiedzie, ale new B()rzuca wyjątek: łapiesz go, aby wznowić normalne wykonywanie programu. Niestety, standard C ++ nie wymaga, aby obiekt A został zniszczony, a jego pamięć zwolniona: pamięć po cichu przecieka i nie ma możliwości jej wyczyszczenia. Owijając A i B, std::make_uniquesmasz pewność, że wyciek nie nastąpi:

void function(std::make_unique<A>(), std::make_unique<B>()) { ... }

Chodzi o to, że std::make_unique<A>i std::make_unique<B>są teraz obiektami tymczasowymi, a czyszczenie obiektów tymczasowych jest poprawnie określone w standardzie C ++: ich destruktory zostaną wyzwolone, a pamięć zwolniona. Więc jeśli możesz, zawsze wolisz przydzielać obiekty za pomocą std::make_uniquei std::make_shared.