Question

Is there a way to prevent shared_from_this() call for a stack-allocated object ?

The enable_shared_from_this<> in the base classes list is a strong indicator for class user, but is there a way to enforce the correct usage ?

Example code:

class C : public enable_shared_from_this<C>
{
public:
  shared_ptr<C> method() { return shared_from_this(); }
};

void func()
{
  C c;
  shared_ptr<C> ptr = c.method(); // exception coming from shared_from_this()
}

Answer 1

So to protect against this problem you can make your constructors private and only provide creation functions that return shared_ptr – this way the object can’t be allocated on the stack, like this:

class C : public enable_shared_from_this<C>
{
public:
  static shared_ptr<C> create() { return shared_ptr<C>(new C() ); }
  shared_ptr<C> method() { shared_from_this(); }

private:
  C() {...}

  // Make operator= and C(const C&) private unimplemented
  // so the used cant do bad things like C c( * c_ptr );
  C& operator=( const C & );
  C( const C & );
};


void func()
{
  C c; // This doesn't compile
  shared_ptr<C> ptr = c.method(); // So you can never get this
}

void altfunc()
{
  shared_ptr<C> c_ptr = C::create();
  C & c_ref = *c;
  shared_ptr<C>  ptr = c_ref.method(); // OK
}

If you find yourself wishing for an operator= you can provide a clone function using a private implemented copy constructor, something like this

// This goes in class C
shared_ptr<C> C::clone() const
{
  return shared_ptr<C>( new C(*this) );
}

// This is how you can use it
shared_ptr<C> c2 = c1->clone();