Implementierung der Singleton-Klasse in C++

In „Design Pattern“ wird Singleton als Rückgabezeiger geschrieben:

class Singleton{
public:
    static Singleton* Instance();
protected:
    Singleton();
private:
    static Singleton* _instance;
};

Die entsprechende Implementierungs-CPP-Datei lautet:

Singleton* Singleton::_instance;
Singleton* Singleton::Instance(){
    if( _instance == 0){
        _instance = new Singleton;
    };
    return _instance;
}

Der Zweck des Entwurfs ist der Konstruktor Geschützt soll verhindern, dass neue Klassen außerhalb der Klasse erstellt werden. Wenn Sie die Möglichkeit in Betracht ziehen, diese Klasse zu erben, ist es besser, den Konstruktor als geschützt zu gestalten, und Sie müssen auch einen virtuellen Destruktor hinzufügen. Um zu verhindern, dass andere das Singleton-Objekt kopieren:

Singleton* pSingleton = Singleton::Instance();
Singleton s1 = *pSingleton;
Singleton s2 = *pSingleton; 
需要将拷贝构造(copy constructor)函数变成 private。

Aber die Frage hier ist, wann sollte das Singleton-Objekt gelöscht werden? Nach einem Grundprinzip von C++ wird das Objekt dort zerstört, wo es erstellt wird. Auch hier sollte es eine Destroy-Methode geben, um das Singleton-Objekt zu löschen. Es wird problematischer, wenn Sie vergessen, es zu löschen. Bei der Instanzfunktion besteht außerdem das Sperrproblem des gleichzeitigen Zugriffs durch mehrere Threads. Wenn Sperren und Entsperren am Anfang und am Ende der Instanzfunktion platziert werden, sinkt die Leistung der gesamten Funktion erheblich. Das ist kein gutes Design.
Es gibt eine kleine Änderung, die das Problem des Speicherverlusts vermeiden kann, das durch das Vergessen des Löschens des Singleton-Objekts verursacht wird. Das heißt, std:auto_ptr zu verwenden, um das Singleton-Objekt zu enthalten, ein statisches Klassenmitglied auto_ptr-Objekt zu definieren und das Singleton-Objekt automatisch zu löschen, wenn die statische auto_ptr-Variable zerstört wird. Um zu verhindern, dass Benutzer Singleton-Objekte löschen, muss der Destruktor von öffentlich auf geschützt geändert werden. Das Folgende ist die Header-Datei SingletonAutoPtr.h:

#include <memory>
using namespace std;
class CSingletonAutoPtr 
{
private:
    static auto_ptr<CSingletonAutoPtr> m_auto_ptr;
    static CSingletonAutoPtr* m_instance;
protected:
    CSingletonAutoPtr();
    CSingletonAutoPtr(const CSingletonAutoPtr&);
    virtual ~CSingletonAutoPtr(); 
    //allow auto_ptr to delete, using protected ~CSingletonAutoPtr()
    friend class auto_ptr<CSingletonAutoPtr>; 
public:
    static CSingletonAutoPtr* GetInstance();
    void Test();
};

#p#Die entsprechende SingletonAutoPtr.cpp lautet wie folgt:

#include "SingletonAutoPtr.h"
#include <iostream>
//initial static member vars here 
CSingletonAutoPtr* CSingletonAutoPtr::m_instance = NULL;
auto_ptr<CSingletonAutoPtr> CSingletonAutoPtr::m_auto_ptr;
/////////////////////////////////////////
// Construction/Destruction
/////////////////////////////////////////
CSingletonAutoPtr::CSingletonAutoPtr()
{
    cout << "CSingletonAutoPtr::CSingletonAutoPtr()" << endl;
    //put single object into auto_ptr object 
    m_auto_ptr = auto_ptr<CSingletonAutoPtr>(this);
}
CSingletonAutoPtr::~CSingletonAutoPtr()
{
    cout << "CSingletonAutoPtr::~CSingletonAutoPtr()" << endl;
}
CSingletonAutoPtr* CSingletonAutoPtr::GetInstance()
{
    //begin lock
    //....
    if(m_instance == NULL)
        m_instance = new CSingletonAutoPtr();
    //end lock
    //...
    return m_instance;
    }
void CSingletonAutoPtr::Test()
{
    cout << "CSingletonAutoPtr::Test()" << endl;
}

Aufrufmethode:

CSingletonAutoPtr* pSingleton = CSingletonAutoPtr::GetInstance();
pSingleton->Test();

Schreiben Sie eins. Es übertrifft unsere Erwartungen, dass Singleton in C++ so viel Aufwand erfordert. Es gibt viele Leute, die auto_ptr noch nie verwendet haben, und std:auto_ptr selbst ist nicht perfekt. Es basiert auf dem Objektbesitzmechanismus. Im Gegensatz dazu gibt es in Apache Log4cxx einen auto_ptr, der auf der Objektzählung basiert und einfacher zu verwenden ist . Log4cxx verwenden zu müssen, nur um einen guten auto_ptr zu verwenden, ist für viele Projekte nicht gut. Natürlich reicht std:auto_ptr in der STL von ANSI C++ aus, um das obige Beispiel zu schreiben.

#p# Eine andere Idee ist, dass es möglicherweise besser ist, die GetInstance-Funktion als statisches Element zu entwerfen, da Singleton-Objekte im Allgemeinen nicht groß sind. Obwohl statische Elemente immer Speicher belegen müssen, ist dies nicht der Fall Problem. Der Destruktor muss hier auf öffentlich eingestellt sein. Das Folgende ist die Header-Datei SingleStaticObj.h

class CSingletonStaticObj 
{
private:
    static CSingletonStaticObj m_instance;
protected:
    CSingletonStaticObj();
    CSingletonStaticObj(const CSingletonStaticObj&);
public:
    virtual ~CSingletonStaticObj(); //must public
    static CSingletonStaticObj& GetInstance();
    void Test();
};
    对应的 SingleStaticObj.cpp 文件为：
#include "SingletonStaticObj.h"
#include <string>
#include <iostream>

using namespace std;
CSingletonStaticObj CSingletonStaticObj::m_instance;
CSingletonStaticObj::CSingletonStaticObj()
{
    cout << "CSingletonStaticObj::CSingletonStaticObj()" << endl;
}
CSingletonStaticObj::~CSingletonStaticObj()
{
    cout << "CSingletonStaticObj::~CSingletonStaticObj()" << endl;
}
CSingletonStaticObj& CSingletonStaticObj::GetInstance()
{
    return m_instance;
}
void CSingletonStaticObj::Test()
{
    cout << "CSingletonStaticObj::Test()" << endl;
}

Aufrufmethode:

CSingletonStaticObj& singleton = CSingletonAutoPtr::GetInstance();singleton.Test();

In Bezug auf die Codegröße scheint die Verwendung statischer Member-Referenzen einfacher zu sein. Ich bevorzuge diese Methode.

Statisches Member-Singleton ist jedoch nicht in allen Situationen geeignet. GetInstance kann beispielsweise nicht verwendet werden, wenn dynamisch entschieden werden muss, verschiedene Instanzen zurückzugeben. Beispielsweise muss FileSystem::GetInstance möglicherweise ein neues WinFileSystem zurückgeben, wenn es unter Windows ausgeführt wird, und möglicherweise ein neues LinuxFileSystem zurückgeben, wenn es unter Linux/Unix ausgeführt wird. In diesem Fall müssen Sie weiterhin die obige auto_ptr-Methode verwenden, die einen Singleton-Zeiger enthält.