enable_shared_from_this (C++ 0x): ¿qué estoy haciendo mal?

Question

Estoy jugando con los punteros inteligentes en el próximo nuevo estándar de C++. Sin embargo, no entiendo el uso de la función shared_from_this. Aquí es lo que tengo:

#include <iostream> 
#include <memory> 

class CVerboseBornAndDie2 : public std::enable_shared_from_this<CVerboseBornAndDie2> 
{ 
public: 
    std::string m_Name; 
    CVerboseBornAndDie2(std::string name) : m_Name(name) 
    { 
     std::cout << m_Name << " (" << this << ") is born!" << std::endl; 
    } 
    virtual ~CVerboseBornAndDie2() 
    { 
     std::cout << m_Name << " (" << this << ") is dying!" << std::endl; 
    } 
}; 

int main(){ 
    CVerboseBornAndDie2* vbad = new CVerboseBornAndDie2("foo"); 
    std::shared_ptr<CVerboseBornAndDie2> p = vbad->shared_from_this(); 
} 

y lanza un std :: bad_weak_ptr excepción en la línea

std::shared_ptr<CVerboseBornAndDie2> p = vbad->shared_from_this(); 

si en lugar de hacer

std::shared_ptr<CVerboseBornAndDie2> p(vbad); 

funciona y lo que puedo hacer después

std::shared_ptr<CVerboseBornAndDie2> p2 = p.get()->shared_from_this(); 

así que debe el objeto pertenecer a un shared_ptr antes de que pueda usar shared_from_this? ¿Pero cómo puedo saber esto de antemano?

Answer 1

Es una condición previa para usar shared_from_this que debe existir al menos un shared_ptr que posee el objeto en cuestión. Esto significa que solo puede usar shared_from_this para recuperar un shared_ptr que posee un objeto del que tiene una referencia o un puntero, no puede usarlo para averiguar si dicho objeto es propiedad de un shared_ptr.

Necesita volver a diseñar su diseño para que tenga garantizado que dicho objeto está siendo administrado por shared_ptr o que no necesita saber o finalmente (y menos deseablemente) crea alguna otra forma de administración este conocimiento.

Answer 2

Para extender la respuesta de Charles, cuando usa enable_shared_from_this, generalmente quiere algo como lo siguiente para garantizar que existe un shared_ptr.

class my_class : public std::enable_shared_from_this<my_class> 
{ 
public: 
    static std::shared_ptr<my_class> create() // can only be created as shared_ptr 
    { 
     return std::shared_ptr<my_class>(new my_class()); 
    } 
private 
    my_class(){} // don't allow non shared_ptr instances. 
};