make_unique e perfetto inoltro

Perché non esiste un std::make_uniquemodello di funzione nella libreria C ++ 11 standard? io trovo

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

un po 'prolisso. Quanto segue non sarebbe molto più bello?

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

Questo nasconde newbene e menziona il tipo solo una volta.

Ad ogni modo, ecco il mio tentativo di implementazione di make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Mi ci è voluto un po 'di tempo per std::forwardcompilare le cose, ma non sono sicuro che sia corretto. È? Cosa std::forward<Args>(args)...significa esattamente ? Cosa ne pensa il compilatore?

Herb Sutter, presidente del comitato di standardizzazione C ++, scrive sul suo blog :

Il fatto che C ++ 11 non includa make_uniqueè in parte una svista e quasi sicuramente verrà aggiunto in futuro.

Fornisce inoltre un'implementazione identica a quella fornita dal PO.

Modifica: std::make_unique ora fa parte di C ++ 14 .

Bello, ma Stephan T. Lavavej (meglio noto come STL) ha una soluzione migliore per make_unique, che funziona correttamente per la versione dell'array.

#include <memory>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::false_type, Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::true_type, Args&&... args) {
   static_assert(std::extent<T>::value == 0,
       "make_unique<T[N]>() is forbidden, please use make_unique<T[]>().");

   typedef typename std::remove_extent<T>::type U;
   return std::unique_ptr<T>(new U[sizeof...(Args)]{std::forward<Args>(args)...});
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
   return make_unique_helper<T>(std::is_array<T>(), std::forward<Args>(args)...);
}

Questo può essere visto nel suo video Core C ++ 6 .

Una versione aggiornata della versione di STL di make_unique è ora disponibile come N3656 . Questa versione è stata adottata nella bozza C ++ 14.

std::make_sharednon è solo una scorciatoia per std::shared_ptr<Type> ptr(new Type(...));. Fa qualcosa di cui non puoi farne a meno.

Per svolgere il proprio lavoro, è std::shared_ptrnecessario allocare un blocco di tracciamento oltre a contenere l'archiviazione per il puntatore effettivo. Tuttavia, poiché std::make_sharedalloca l'oggetto reale, è possibile std::make_sharedallocare sia l'oggetto che il blocco di tracciamento nello stesso blocco di memoria.

Quindi, mentre std::shared_ptr<Type> ptr = new Type(...);due allocazioni di memoria (una per il new, una nel std::shared_ptrblocco di tracciamento) std::make_shared<Type>(...)assegnerebbero un blocco di memoria.

Questo è importante per molti potenziali utenti di std::shared_ptr. L'unica cosa std::make_uniqueche farebbe è essere leggermente più conveniente. Nient'altro.

Mentre nulla ti impedisce di scrivere il tuo aiutante, credo che il motivo principale per fornire make_shared<T>nella libreria sia che in realtà crea un tipo di puntatore condiviso diverso da quello shared_ptr<T>(new T), che è allocato in modo diverso, e non c'è modo di farlo senza l'apposito aiutante.

make_uniqueD'altra parte, il tuo involucro è un semplice zucchero sintattico attorno a newun'espressione, quindi mentre può sembrare piacevole alla vista, non porta nulla newsul tavolo. Correzione: questo non è in realtà vero: avere una chiamata di funzione per racchiudere l' newespressione fornisce una sicurezza eccezionale, ad esempio nel caso in cui si chiama una funzione void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Avere due raw newnon seguiti l'uno rispetto all'altro significa che se una nuova espressione fallisce con un'eccezione, l'altra può perdere risorse. Per quanto riguarda il motivo per cui non esiste make_uniqueuno standard: è stato appena dimenticato. (Questo succede di tanto in tanto. Inoltre, non esiste alcun globale std::cbeginnello standard, anche se dovrebbe essercene uno.)

Si noti inoltre che unique_ptraccetta un secondo parametro modello che in qualche modo dovresti consentire; questo è diverso da quello shared_ptr, che utilizza la cancellazione del tipo per memorizzare i deleter personalizzati senza renderli parte del tipo.

In C ++ 11 ...viene utilizzato (nel codice modello) anche per "espansione del pacchetto".

Il requisito è che tu lo usi come suffisso di un'espressione contenente un pacchetto di parametri non espanso e applicherà semplicemente l'espressione a ciascuno degli elementi del pacchetto.

Ad esempio, basandoti sul tuo esempio:

std::forward<Args>(args)... -> std::forward<int>(1), std::forward<int>(2),
                                                     std::forward<int>(3)

std::forward<Args...>(args...) -> std::forward<int, int, int>(1,2,3)

Quest'ultima essendo errata, penso.

Inoltre, il pacchetto di argomenti non può essere passato a una funzione non espansa. Non sono sicuro di un pacchetto di parametri del modello.

Ispirato dall'implementazione di Stephan T. Lavavej, ho pensato che sarebbe stato bello avere un make_unique che supportasse le estensioni dell'array, è su github e mi piacerebbe ricevere commenti. Ti permette di fare questo:

// create unique_ptr to an array of 100 integers
auto a = make_unique<int[100]>();

// create a unique_ptr to an array of 100 integers and
// set the first three elements to 1,2,3
auto b = make_unique<int[100]>(1,2,3);