enable_shared_from_this y objetos en la pila

Question

¿Qué pasa con la llamada shared_from_this para apilar objetos asignados? enable_shared_from_this en la lista de las clases base es un indicador para el usuario de la clase derivada para crearlo solo en el montón (y solo esperamos el uso correcto de la clase) o podemos tener una protección más fuerte contra tales errores. O no entiendo algunos momentos? código

Ejemplo:

 
class C : public enable_shared_from_this<C> 
{ 
public: 
    shared_ptr<C> method() { shared_from_this(); } 
};
 

void func() { C c; shared_ptr<C> ptr = c.method(); // exception comming from shared_from_this() } 

Answer 1

Así que para proteger contra este problema, puede hacer que sus contstructors privado y sólo proporcionan funciones de creación que devuelven shared_ptr - de esta manera el objeto no puede ser asignado en la pila, así:

class C : public enable_shared_from_this<C> 
{ 
public: 
    static shared_ptr<C> create() { return shared_ptr<C>(new C()); } 
    shared_ptr<C> method() { shared_from_this(); } 

private: 
    C() {...} 

    // Make operator= and C(const C&) private unimplemented 
    // so the used cant do bad things like C c(* c_ptr); 
    C& operator=(const C &); 
    C(const C &); 
}; 


void func() 
{ 
    C c; // This doesnt compile 
    shared_ptr<C> ptr = c.method(); // So you can never get this 
} 

void altfunc() 
{ 
    shared_ptr<C> c_ptr = C::create(); 
    C & c_ref = *c; 
    shared_ptr<C> ptr = c_ref.method(); // OK 
} 

Si usted se encuentra deseando anoperator = se puede proporcionar una función de clonación usando un constructor de copia privada en práctica, algo como esto

// This goes in class C 
shared_ptr<C> C::clone() const 
{ 
    return shared_ptr<C>(new C(*this)); 
} 

// This is how you can use it 
shared_ptr<C> c2 = c1->clone();