shared_ptr - c++ make_unique
Diferencias entre std:: make_unique y std:: unique_ptr (3)
¿Tiene std::make_unique
algún beneficio de eficiencia como std::makes_shared
?
Comparado con la construcción manual de std::unique_ptr
:
std::make_unique<int>(1); // vs
std::unique_ptr<int>(new int(1));
La motivación detrás de make_unique
es principalmente doble:
make_unique
es seguro para crear temporarios, mientras que con el uso explícito denew
tienes que recordar la regla sobre no usar temporarios sin nombre.foo(make_unique<T>(), make_unique<U>()); // exception safe foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*
La adición de
make_unique
finalmente significa que podemos decirle a la gente que ''nunca'' use la reglanew
lugar de la anterior para "nunca usar ''lanew
excepto cuando se hace ununique_ptr
".
También hay una tercera razón:
-
make_unique
no requiere el uso de tipos redundantes.unique_ptr<T>(new T())
->make_unique<T>()
Ninguno de los motivos implica mejorar la eficiencia del tiempo de ejecución de la misma forma que usa make_shared
(debido a que se evita una segunda asignación, a costa de un uso potencialmente mayor de la memoria de pico).
* Se espera que C ++ 17 incluya un cambio de regla que signifique que esto ya no es inseguro. Ver los documentos del comité C ++ P0400R0 y P0145R3 .
Una razón por la cual tendría que usar std::unique_ptr(new A())
o std::shared_ptr(new A())
directamente en lugar de std::make_*()
no puede acceder al constructor de clase A
fuera del alcance actual.
std::make_unique
y std::make_shared
están ahí por dos razones:
- Para que no tenga que enumerar explícitamente los argumentos del tipo de plantilla.
- Seguridad de excepción adicional sobre el uso de constructores
std::unique_ptr
ostd::shared_ptr
. (Consulte la sección de Notas here ).
No se trata realmente de la eficiencia en el tiempo de ejecución. Hay un poco sobre el bloque de control y el T
asignado de una vez, pero creo que es más una ventaja y menos una motivación para que estas funciones existan.