Atualmente, estou aprendendo a usar os ponteiros inteligentes do C ++ 11 durante a programação de um mecanismo de jogo 2D como hobby usando o SDL. No entanto, me deparei com um problema ao implementar um wrapper OOp para SDL.

A intenção é criar uma classe singleton, que inicializa o SDL quando ele é construído, e desliga o SDL quando ele é destruído. A classe singleton tem um método estáticogetInstance que retorna umshared_ptr para o singleton, e constrói a instância única se nenhuma instância existir, a idéia é que todos os clientes do singleton possuam umshared_ptr para isso, e quando todos os clientes são destruídos, o singleton também é destruído. Eu entendo que singletons (e outros globals) são geralmente ruins, mas eu acho que este poderia ser um dos poucos casos em que um singleton é apropriado, já que só pode haver uma biblioteca SDL em uso.

O problema está em devolver oshared_ptr degetInstance método. Em vez de usar o mesmoshared_ptr objeto gerenciador, oshared_ptr instâncias não estão relacionadas, e destruir um único deles desaloca o 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();
}

Saída:

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