Ultra Software Company Blog

The problem you're describing in the end can be solved with by deriving from "std::enable_shared_from_this" (http://en.cppreference.com/w/cpp/memory/enable_shared_from_this). This basically does what you planned with the weak_ptr-stuff but without additional overhead on your side.

Translating your code-example, this would be:

#include <memory>
#include <iostream>
using namespace std;
class Thing : public enable_shared_from_this<Thing>
{
public:
	shared_ptr<Thing> GetSelf();
};

shared_ptr<Thing> Thing::GetSelf()
{
	return shared_from_this();
}

int main(int argc, const char *argv[])
{
	shared_ptr<Thing> p1 = make_shared<Thing>();
	shared_ptr<Thing> p2 = p1->GetSelf();
}

EDIT: It is important to derive publicly! In the example of the cppreference-link, they are using a struct, which derives publicly by default. For classes, you have to explicitly write ": public". I edited the code above

Edited August 17, 2017 by Ma-Shell

Great, thanks for pointing that out!  I have verified this works as expected:

#include <memory>
#include <iostream>

class Thing : public enable_shared_from_this<Thing>
{
public:
	~Thing();
	shared_ptr<Thing> GetSelf();
};

Thing::~Thing() {}// <-- set breakpoint here

shared_ptr<Thing> Thing::GetSelf()
{
	return shared_from_this();
}

int main(int argc, const char *argv[])
{
	shared_ptr<Thing> p1 = make_shared<Thing>();
	shared_ptr<Thing> p2 = p1->GetSelf();
	p1 = nullptr;
	int k = 0;// <-- set breakpoint here
}

And this example shows how you can make derived classes return their own shared pointer:

//#include <memory>
//#include <iostream>
//using namespace std;

class Thing : public enable_shared_from_this<Thing>
{
public:
	~Thing();
	shared_ptr<Thing> GetSelf();
};

Thing::~Thing() {}// <-- set breakpoint here

shared_ptr<Thing> Thing::GetSelf()
{
	return shared_from_this();
}

class SubThing : public Thing
{
public:
	~SubThing();
	shared_ptr<SubThing> GetSelf();
};

SubThing::~SubThing() {}// <-- set breakpoint here

shared_ptr<SubThing> SubThing::GetSelf()
{
	return static_pointer_cast<SubThing>(shared_from_this());
}

int main(int argc, const char *argv[])
{
	SubThing* subthing = new SubThing;
	shared_ptr<Thing> p1 = shared_ptr<Thing>(subthing);
	shared_ptr<SubThing> p2 = subthing->GetSelf();
	p1 = nullptr;
	int k = 0;// <-- set breakpoint here
}

 

Okay, I created a "SharedObject" class.  Everything that's not a simple math class should be derived from this:

class SharedObject : public Object, public enable_shared_from_this<SharedObject> {};

You can create a new class like this:

class MyClass : public SharedObject
{
	shared_ptr<MyClass> GetSelf();
};

And you can return the object itself safely like this:

shared_ptr<MyClass> MyClass::GetSelf()
{
	return static_pointer_cast<MyClass>(shared_from_this());
}