Pass weak this pointer to its own function

Question

Is it a good idea to have code like this: Any pitfalls ? Is it a better design to use shared this pointer ?

class X { 
   public:
   void foo();
   void bar2(const boost::weak_ptr<X>& x); 
};

void X::foo() {}
void X::bar2(const boost::weak_ptr<X>& x) {}
void foo() 
{
    const boost::shared_ptr<X> x = boost::make_shared<X>();
    boost::weak_ptr<X> weakX(x);
    x->bar2(weakX);
}

int 
main()
{
    foo();
    return 0;
}

The code is correct (It might have design issues, not revealed) — , Jun 15 '15 at 18:44
The obvious pitfall is this pointer being a regular pointer hence you may run into a situation where the object gets destroyed while a member function is running, take care. You may want to have a look at std::/boost:: enable_shared_from_this. Same pitfalls. — Nick Zavaritsky, Jun 15 '15 at 19:28

score 0 · Answer 1 · answered Jun 15 '15 at 19:34

If the argument passed in to the function is supposed to always be a weak_ptr-version of this you have a problem. There is nothing in the code enforcing this behaviour, so a user of your class could just as easily pass a weak_ptr to another object of class X.

If what you need is for bar2 to be able to pass on a shared_ptr to this, a better solution is to use std::enable_shared_from_this

Example

#include <iostream>
#include <memory>

struct Foo : public std::enable_shared_from_this<Foo> {
    Foo() { std::cout << "Foo::Foo\n"; }
    ~Foo() { std::cout << "Foo::~Foo\n"; } 
    std::shared_ptr<Foo> getFoo() { return shared_from_this(); }
};

int main() {
    Foo *f = new Foo;
    std::shared_ptr<Foo> pf1;

    {
        std::shared_ptr<Foo> pf2(f);
        pf1 = pf2->getFoo();  // shares ownership of object with pf2
    }

    std::cout << "pf2 is gone\n";   
}

Output:

Foo::Foo
pf2 is gone
Foo::~Foo

from http://en.cppreference.com/w/cpp/memory/enable_shared_from_this/shared_from_this

Pass weak this pointer to its own function

1 Answers1