Re: [Boost-users] shared_from_this - derived classes (yes, I googled)

Subject: Re: [Boost-users] shared_from_this - derived classes (yes, I googled)
From: Christopher Pisz (cpisz_at_[hidden])
Date: 2011-10-01 15:51:33

Igor R <boost.lists <at> gmail.com> 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 <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>

//--------------------------
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<B, A>(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;
}