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 <boost/enable_shared_from_this.hpp> #include <boost/make_shared.hpp> #include <boost/smart_ptr.hpp> #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