Igor R writes:
I inherited from enable_shared_from_this in my base class.
When I called shared_from_this() in my derived class it throws an exception.
When I go up the call stack I see that in the boost implementation weak_ptr
is
NULL and count is NULL.
I ensured the derived class was instatiated as a shared_ptr by using a
fatory method.
If you create shared_ptr, as you described, and then call
shared_from_this(), it should not throw exceptions. If it does, can
you provide a trivial reproducing sample?
Well, I tried to get a trivial example and ended up having a working example. I
suppose my problem is in the non-trivial part of my code :)
Is this the correct way to do it?
#include <iostream>
#include
#include
//--------------------------
class A : public boost::enable_shared_from_this<A>
{
public:
///
typedef boost::shared_ptr<A> SmartPtr;
///
static A::SmartPtr Create()
{
A::SmartPtr instance;
// Check arguments if any
// Create an instance of this class
instance.reset(new A());
return instance;
}
virtual ~A()
{
}
protected:
A()
{
}
};
//--------------------------
class B : public A
{
public:
///
typedef boost::shared_ptr<B> SmartPtr;
///
static B::SmartPtr Create()
{
B::SmartPtr instance;
// Check arguments if any
// Create an instance of this class
instance.reset(new B());
return instance;
}
///
virtual ~B()
{
}
///
B::SmartPtr Foo()
{
A::SmartPtr temp = shared_from_this();
B::SmartPtr me = boost::shared_dynamic_cast(temp);
return me;
}
///
void Bar() const
{
std::cout << "Success!" << std::endl;
}
protected:
///
B()
:
A()
{
}
};
//--------------------------
int main()
{
B::SmartPtr b1 = B::Create();
B::SmartPtr b2 = b1->Foo();
if( b1 != b2 )
{
std::cout << "they aren't equal." << std::endl;
return 1;
}
b2->Bar();
return 0;
}
