In my code base, we use the wonderful enable_shared_from_this template quite
frequently. However, I came across an *interesting* problem while mocking
some classes for unit tests. I compiled the following code with g++ 4.4.3
and Boost 1.46.1 (the same as the attached code):
#include
#include
#include
#include <iostream>
class base :
public boost::enable_shared_from_this<base>
{
public:
boost::shared_ptr<base> get_shared_from_base()
{
return shared_from_this();
}
};
class derived :
public base,
public boost::enable_shared_from_this<derived>
{
public:
boost::shared_ptr<derived> get_shared_from_derived()
{
return boost::enable_shared_from_this<derived>::shared_from_this();
}
};
int main()
{
boost::shared_ptr<derived> thing = boost::make_shared<derived>();
boost::shared_ptr<derived> derived_thing =
thing->get_shared_from_derived();
boost::shared_ptr<base> base_thing = thing->get_shared_from_base();
return 0;
}
This is what I expect: I expect the get_shared_from_derived call to work,
since the _internal_accept_owner would visit it. I would also expect the
call to get_shared_from_base to fail with a bad_weak_ptr, since it looks
like there is only one call in shared_ptr's constructor. I expect that the
actual behavior is probably undefined, since it would depend on which
association the compiler feels more strongly about: the
enable_shared_from_this<derived> from derived or the
enable_shared_from_this<base> from base.
What I expect is, of course, not happening, which is why I turn to the Boost
gurus. *Neither* of the calls work: they both fail with a bad_weak_ptr.
Why would this happen?
--
- Travis Gockel
