Ich lerne gerade, wie man die intelligenten Zeiger von C ++ 11 benutzt, während man eine 2D-Game-Engine mit SDL als Hobby programmiert. Beim Implementieren eines OOp-Wrappers für SDL trat jedoch ein Problem auf.

Die Absicht ist, eine Singleton-Klasse zu erstellen, die SDL beim Erstellen initialisiert und SDL herunterfährt, wenn es zerstört wird. Die Singleton-Klasse verfügt über eine statische MethodegetInstance das ergibt ashared_ptr erstellt die einzelne Instanz, wenn keine Instanz vorhanden ist. Dabei wird davon ausgegangen, dass alle Clients des Singletons eine besitzenshared_ptr Wenn alle Clients zerstört werden, wird auch der Singleton zerstört. Ich verstehe, dass Singletons (und andere Globals) im Allgemeinen schlecht sind, aber ich denke, dass dies einer der wenigen Fälle sein kann, in denen ein Singleton geeignet ist, da nur eine SDL-Bibliothek verwendet werden kann.

Das Problem liegt in der Rücksendung dershared_ptr von demgetInstance Methode. Anstatt dasselbe zu verwendenshared_ptr Manager Objekt, dasshared_ptr Instanzen haben keine Beziehung zueinander, und durch das Zerstören einer einzelnen Instanz wird der Singleton freigegeben.

#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();
}

Ausgabe:

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