Actualmente estoy aprendiendo a usar los punteros inteligentes de C ++ 11 mientras programo un motor de juego 2D como un pasatiempo usando SDL. Sin embargo, me encontré con un problema al implementar un contenedor OOp para SDL.

La intención es crear una clase singleton, que inicializa SDL cuando se construye, y apaga SDL cuando se destruye. La clase singleton tiene un método estático.getInstance que devuelve unshared_ptr al singleton, y construye la instancia única si no existe ninguna instancia, la idea es que todos los clientes del singleton poseen unshared_ptr para ello, y cuando todos los clientes se destruyen, el singleton también se destruye. Entiendo que los singletons (y otros globales) son generalmente malos, pero creo que este podría ser uno de los pocos casos en que un singleton es apropiado, ya que solo puede haber una biblioteca SDL en uso.

El problema radica en devolver elshared_ptr desde elgetInstance método. En lugar de usar el mismoshared_ptr objeto administrador, elshared_ptr los casos no están relacionados, y la destrucción de uno solo de ellos desasigna el singleton.

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

class Foo
{
public:
    ~Foo(){cout << "Foo <" << this << "> destroyed\n"; instance_ = nullptr;}
    static shared_ptr<Foo> getInstance()
    {
        if(instance_ == nullptr)
            instance_ = new Foo;
        //problem: the shared pointers created are unaware of each other
        return shared_ptr<Foo>(instance_);
    }
private:
    Foo(){cout << "Foo <" << this << "> constructed\n";}
    Foo(Foo& other){}
    void operator=(Foo& other){}
    static Foo* instance_;
};

Foo* Foo::instance_ = nullptr;

int main()
{
    shared_ptr<Foo> a = Foo::getInstance();
    shared_ptr<Foo> b = Foo::getInstance();
    shared_ptr<Foo> c = Foo::getInstance();
}

Salida:

Foo <0x3e2a10> constructed
Foo <0x3e2a10> destroyed
Foo <0x3e2a10> destroyed
Foo <0x3e2a10> destroyed