¿Los punteros inteligentes excluyen la necesidad de una construcción en dos fases?

Question

construcción de dos fases toma la siguiente forma:

struct something { 
    something() 
     : p1(NULL) 
     , p2(NULL) 
    { } 

    ~something() { 
     if (p1) delete p1; 
     if (p2) delete p2; 
    } 

    void initialize() { 
     p1 = new int(2); 
     p2 = new int(5); // May throw if allocation fails! 
    } 

    int* p1; 
    int* p2; 
}; 

el punto de que es que un constructor ingenuo (que no reloj por errores de asignación) será pérdida de memoria: destructor de un objeto construido parcialmente nunca es llamado .

Mi pregunta: ¿es seguro el siguiente código, y por corrolario, los punteros inteligentes obvian la construcción de dos fases?

struct something { 
    something() 
     : p1(new int(2)) 
     , p2(new int(5)) 
    { } 

    std::unique_ptr<int> p1; 
    std::unique_ptr<int> p2; 
}; 

Answer 1

Sí, su nuevo código está bien. Tenga en cuenta sin embargo, que hay una posible sutilmente en los casos más complejos:

#include <memory> 

struct foo { 
    foo(std::shared_ptr<int> a, std::shared_ptr<int> b) { } 
}; 

struct bar { 
    foo f; 
    bar() : f(std::shared_ptr<int>(new int), std::shared_ptr<int>(new int)) { } 
}; 

int main() { 
    bar b; 
} 

no sería seguro sin embargo ya que el orden de evaluación de los argumentos del constructor de foo en la lista de inicialización de bar está especificado. Un compilador conforme puede elegir hacer un primer orden de evaluación de profundidad o de amplitud (o cualquier otra cosa siempre que todos sean evaluados correctamente al final). Esto significa que si el primer new int tuvo éxito, pero el segundo tira antes de que se construyan los objetos shared_ptr, la primera asignación que se realizará aún podría tener fugas.

Si desea hacer esto, hay dos soluciones posibles, además de simplemente volver a la construcción en dos fases: la primera podría ser un refactorizador, la segunda sería construir primero las shared_ptr individualmente como miembros de la barra , antes de f. Cuál de los dos es más apropiado es una decisión que creo que debe tomarse caso por caso.

Answer 2

Mi pregunta: ¿es el siguiente código de seguridad,

Sí, eso estaría bien.

struct something { 
    something() 
     : p(new int(5)) 
    { } 

    std::unique_ptr<int> p; 
}; 

Tenga en cuenta que el código ingenua

struct something { 
    something() 
     : p(new int(5)) 
    { } 

    int* p; 
}; 

estaría a salvo excepción, también, porque sólo hay una asignación que puede fallar. Creo que estás hablando más bien de

struct something { 
    something() 
     : p(new int(5)), q(new int) 
    { } 

    int *p, *q; 
}; 

que no. Los indicadores inteligentes también funcionarían en ese caso.

Answer 3

No necesita construcción en dos fases si simplemente maneja la excepción. Este es el camino de RIAA.

struct something { 
    something() 
     : p1(NULL) 
     , p2(NULL) 
    { 
     p1 = new int(2); 
     try { 
      p2 = new int(5); // May throw if allocation fails! 
     } catch (std::bad_alloc&) { 
      delete p1; //cleanup 
      throw; //rethrow 
     } 
    } 

    ~something() { 
     delete p1; 
     delete p2; 
    } 

    int* p1; 
    int* p2; 
};