make_unique y reenvío perfecto

¿Por qué no hay std::make_uniqueuna plantilla de función en la biblioteca estándar de C ++ 11? Encuentro

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

Un poco detallado. ¿No sería mucho mejor lo siguiente?

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

Esto oculta newmuy bien y solo menciona el tipo una vez.

De todos modos, aquí está mi intento de implementar 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)...));
}

Me llevó bastante tiempo std::forwardcompilar las cosas, pero no estoy seguro de si es correcto. ¿Lo es? ¿Qué std::forward<Args>(args)...significa exactamente ? ¿Qué hace el compilador de eso?

Herb Sutter, presidente del comité de estandarización de C ++, escribe en su blog :

Que C ++ 11 no incluya make_uniquees en parte un descuido, y casi seguramente se agregará en el futuro.

También ofrece una implementación que es idéntica a la dada por el OP.

Editar: std::make_unique ahora es parte de C ++ 14 .

Agradable, pero Stephan T. Lavavej (mejor conocido como STL) tiene una mejor solución make_unique, que funciona correctamente para la versión de matriz.

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

Esto se puede ver en su video Core C ++ 6 .

Una versión actualizada de la versión de STL de make_unique ahora está disponible como N3656 . Esta versión fue adoptada en el borrador de C ++ 14.

std::make_sharedno es solo taquigrafía para std::shared_ptr<Type> ptr(new Type(...));. Hace algo que no puedes hacer sin él.

Para hacer su trabajo, std::shared_ptrdebe asignar un bloque de seguimiento además de mantener el almacenamiento para el puntero real. Sin embargo, debido a que std::make_sharedasigna el objeto real, es posible que std::make_sharedasigne tanto el objeto como el bloque de seguimiento en el mismo bloque de memoria.

Entonces, si bien std::shared_ptr<Type> ptr = new Type(...);serían dos asignaciones de memoria (una para el new, una en el std::shared_ptrbloque de seguimiento), std::make_shared<Type>(...)asignaría un bloque de memoria.

Eso es importante para muchos usuarios potenciales de std::shared_ptr. Lo único que std::make_uniqueharía es ser un poco más conveniente. Nada más que eso.

Si bien nada le impide escribir su propio ayudante, creo que la razón principal para proporcionar make_shared<T>en la biblioteca es que en realidad crea un tipo interno diferente de puntero compartido que shared_ptr<T>(new T), que está asignado de manera diferente, y no hay forma de lograr esto sin el dedicado ayudante.

Su make_uniqueenvoltura, por otro lado, es un mero azúcar sintáctico alrededor de una newexpresión, por lo que, aunque pueda parecer agradable a la vista, no aporta nada newa la mesa. Corrección: de hecho, esto no es cierto: tener una llamada de función para ajustar la newexpresión proporciona seguridad de excepción, por ejemplo, en el caso de que llame a una función void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Tener dos news sin procesar sin secuencia uno con respecto al otro significa que si una nueva expresión falla con una excepción, la otra puede perder recursos. En cuanto a por qué no hay make_uniqueun estándar: simplemente se olvidó. (Esto sucede ocasionalmente. Tampoco hay un std::cbeginestándar global en el estándar aunque debería haber uno).

También tenga en cuenta que unique_ptrtoma un segundo parámetro de plantilla que de alguna manera debería permitir; esto es diferente de shared_ptr, que utiliza el borrado de tipos para almacenar eliminadores personalizados sin hacerlos parte del tipo.

En C ++ 11 también ...se usa (en el código de la plantilla) para la "expansión del paquete".

El requisito es que lo use como sufijo de una expresión que contiene un paquete de parámetros sin expandir, y simplemente aplicará la expresión a cada uno de los elementos del paquete.

Por ejemplo, basándose en su ejemplo:

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)

El último es incorrecto, creo.

Además, el paquete de argumentos no se puede pasar a una función sin expandir. No estoy seguro acerca de un paquete de parámetros de plantilla.

Inspirado por la implementación de Stephan T. Lavavej, pensé que sería bueno tener un make_unique que admitiera extensiones de matriz, está en github y me encantaría recibir comentarios al respecto. Te permite hacer esto:

// 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);