Re: [Boost-users] [SmartPtr] enable_shared_from_raw / weak_from_raw remains not associated

17 May 2013

      On Thu, 16 May 2013 20:09:58 +0200, Frank Mori Hess   
wrote:
...
On Thu, May 16, 2013 at 5:58 AM, Slava
 wrote:
...
I'm converting existing code with parent-child object tree to boost
shared_ptr/weak_ptr with parents having [now shared] ownership over the
children and children having weak reference to the parent. In the  
existing
code a parent usually becomes the children as constructor parameters,  
and
thus I have to extract the weak_ptr to "this" in constructor, which  
does not
work with current boost::enable_shared_from_this implementation. So I am
looking to enable_shared_from_raw alternative, which is promising, but
unfortunately does not quite work for my case. Here is a small example
demonstrating the issue:
...
struct Parent : public boost::enable_shared_from_raw
{
    Parent(boost::shared_ptr<Child> _child)
    {
        std::cout << "Construct Parent" << std::endl;
        this->child = _child;
        this->child->parent = boost::weak_from_raw(this);
    }
weak_from_raw() doesn't work until after a shared_ptr has taken
ownership of the object or shared_from_raw()  has been called.  It's
been long enough don't remember what the rationale for this was, or if
there even was a rationale, but the enable_shared_from_raw test case
seems to expect this behavior.  From looking at the code, it seems
like if you just called shared_from_raw prior to calling weak_from_raw
it would work.
Thanks, right, the test cases, I always forget they are the good source of  
information!
The example works as expected (difference to previous is only addition of  
boost::shared_from_raw(this) in constructor):

#include 
#include <iostream>

struct Parent;

struct Child
{
     Child()
     {
         std::cout << "Construct Child" << std::endl;
     }
     ~Child()
     {
         std::cout << "Destruct Child" << std::endl;
     }

     boost::weak_ptr<Parent> parent;
};

struct Parent : public boost::enable_shared_from_raw
{
     Parent(boost::shared_ptr<Child> _child)
     {
         std::cout << "Construct Parent" << std::endl;
         this->child = _child;
         boost::shared_from_raw(this);	// necessary for weak_from_raw() to  
function properly
         this->child->parent = boost::weak_from_raw(this);
     }

     ~Parent()
     {
         std::cout << "Destruct Parent" << std::endl;
     }

     boost::shared_ptr<Child> child;
};

int main()
{
     boost::shared_ptr<Child> child(new Child());
     boost::shared_ptr<Parent> parent(new Parent(child));
     std::cout << "child->parent is " << (child->parent.lock() ? "not null"  
: "null") << std::endl;
     parent.reset();
     std::cout << "child must be alone" << std::endl;
     std::cout << "child->parent is " << (child->parent.lock() ? "not null"  
: "null") << std::endl;
     return 0;
}

output:
==2269== Memcheck, a memory error detector
==2269== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==2269== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==2269== Command: a.out
==2269==
Construct Child
Construct Parent
child->parent is not null
Destruct Parent
child must be alone
child->parent is null
Destruct Child
==2269==
==2269== HEAP SUMMARY:
==2269==     in use at exit: 0 bytes in 0 blocks
==2269==   total heap usage: 5 allocs, 5 frees, 152 bytes allocated
==2269==
==2269== All heap blocks were freed -- no leaks are possible
==2269==
==2269== For counts of detected and suppressed errors, rerun with: -v
==2269== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

I reached what I needed, but I have some bad feeling about how it works.  
It does not look sane, boost::shared_from_raw(this) class is there only to  
produce the desired side effect.

-- Slava