C++ manage heap/pointers in a singleton - c++

Question

I have a singleton with attributes which are pointers.
How do I prevent a memory leak when I no longer use it i.e. when the last reference to my instance is popped off the stack frame?
Does the destructor get called each time a reference gets poped off the stack?
A &A::getInstance()
{
static A instance; // does this get deleted at any point?
return instance;
}

Answer 1

Your singleton object will exist for the lifetime of the program and will be destroyed some time after main ends. At that point it's destructor will be invoked.
Here you may delete your raw pointers (or if using smart, you can set to nullptr or call reset).
This can be seen in action with the example below:
#include <iostream>
#include <string>
#include <memory>
class Foo
{
public:
Foo(std::string const& name = "Unknown")
: m_sName{ name }
{
std::cout << m_sName << " is created" << std::endl;
}
~Foo()
{
std::cout << m_sName << " is being destroyed" << std::endl;
}
std::string m_sName;
};
class Singleton
{
public:
static Singleton& Get()
{
static Singleton instance;
return instance;
}
~Singleton()
{
delete m_RawFoo;
m_SmartFoo = nullptr;
}
void print() const
{
std::cout << "Hello World" << std::endl;
}
protected:
private:
Singleton()
{
m_RawFoo = new Foo{ "Raw Foo" };
m_SmartFoo = std::make_shared<Foo>("Shared Foo");
}
Foo* m_RawFoo;
std::shared_ptr<Foo> m_SmartFoo;
};
int main()
{
std::cout << "Starting main..." << std::endl;
Singleton::Get().print();
Singleton::Get().print();
std::cout << "Ending main..." << std::endl;
return 0;
}
Which outputs the following:
Starting main...
Raw Foo is created
Shared Foo is created
Hello World
Hello World
Ending main...
Raw Foo is being destroyed
Shared Foo is being destroyed

Answer 2

I usually use shared_ptr and weak_ptr for singletons. The following is a singleton which is alive only while there are references to it. Note that this is not entirely thread-safe. If you want thread-safety, you'll need some additional logic (probably a lock) in GetInstance.
#include <memory>
class MySingleton
{
// singleton
public:
static std::shared_ptr<MySingleton> GetInstance();
private:
static std::weak_ptr<MySingleton> instance__;
// lifecycle
private:
MySingleton();
public:
~MySingleton();
// delete the copy constructor, move constructor, copy operator and move operator
private:
MySingleton(const MySingleton&) = delete;
MySingleton(MySingleton&&) = delete;
MySingleton& operator=(const MySingleton&) = delete;
MySingleton& operator=(MySingleton&&) = delete;
};
std::shared_ptr<MySingleton> MySingleton::GetInstance()
{
auto instance = instance__.lock();
if (!instance) {
instance.reset(new MySingleton);
instance__ = instance;
}
return instance;
}
std::weak_ptr<MySingleton> MySingleton::instance__;
MySingleton::MySingleton()
{
// initialization logic here
}
MySingleton::~MySingleton()
{
// clean-up logic here
}
Here's some sample client code:
int main()
{
// proper usage -- store the reference in a stack variable for the duration of its use
{
auto instance = MySingleton::GetInstance();
instance->doSomething();
instance->doSomethingElse();
// instance shared_ptr will be destructed automatically,
// which will then destruct the MySingleton instance
}
// BAD USAGE -- failing to store the reference will cause a new instance to be created and destroyed with each call
{
MySingleton::GetInstance()->doSomething();
MySingleton::GetInstance()->doSomethingElse();
}
// proper usage -- store the reference in a struct or class whose lifecycle is managed appropriately
{
// this class takes a shared reference and stores it
class Foo
{
public:
Foo(const std::shared_ptr<MySingleton>& dependency) : dependency_(dependency) { }
private:
std::shared_ptr<MySingleton> dependency_;
};
// this instance will store a shared reference
auto f = new Foo(MySingleton::GetInstance());
// when the destructor is invoked, the shared_ptr will be destructed,
// which will then destruct the MySingleton instance
delete f;
}
return 0;
}