Diferencias entre std:: make unique y std:: unique ptr

Question

Diferencias entre std:: make unique y std:: unique ptr

¿Tiene std::make_unique algún beneficio de eficiencia como std::makes_shared?

Comparado con la construcción manual std::unique_ptr:

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

77

c++c++11 unique-ptr smart-pointers c++14

Author: Guy Avraham, 2014-03-22

Source

3 answers

std::make_unique y std::make_shared están ahí por dos razones:

Para que no tenga que listar explícitamente los argumentos de tipo de plantilla.
Seguridad de excepción adicional sobre el uso de constructores std::unique_ptr o std::shared_ptr. (Véase la sección de Notas aquí.)

No se trata realmente de la eficiencia del tiempo de ejecución. Está el bit sobre el bloque de control y el T que se asigna todo a la vez, pero creo que es más una ventaja y menos una motivación para que estas funciones existan.

9

Author: Timothy Shields,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2014-03-21 23:31:29

Una razón por la que tendría que usar std::unique_ptr(new A()) o std::shared_ptr(new A()) directamente en lugar de std::make_*() es no poder acceder al constructor de la clase A fuera del ámbito actual.

4

Author: Volodymyr Lashko,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2017-07-20 09:16:18

score 95 · Accepted Answer

La motivación detrás de make_unique es principalmente doble: {[13]]}

make_unique es seguro para crear temporarios, mientras que con el uso explícito de new debe recordar la regla de 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 new en lugar de la regla anterior de "'nunca' use new excepto cuando haga un unique_ptr".

También hay un tercero razón:

make_unique no requiere el uso de tipos redundantes. unique_ptr<T>(new T()) -> make_unique<T>()

Ninguna de las razones implica mejorar la eficiencia del tiempo de ejecución de la manera en que se usa make_shared (debido a evitar una segunda asignación, a costa de un pico de uso de memoria potencialmente más alto).

* Se espera que C++17 incluya un cambio de regla que significa que esto ya no es inseguro. Véanse los documentos del comité de C++ P0400R0 y P0145R3.