Detaillierte Erläuterung der C++-Singleton-Klassenvorlage

In diesem Artikel wird hauptsächlich die C++-Singleton-Klassenvorlage vorgestellt. Der Artikel führt sie ausführlich anhand von Beispielcode ein. Sie hat einen gewissen Referenzlernwert für das Studium oder die Arbeit aller. Freunde, die es benötigen, können dem Herausgeber von Weidian Reading folgen, um gemeinsam zu lernen .

Singleton-Klasse

beschreiben

Dies bedeutet, dass eine Klasse im gesamten Systemlebenszyklus höchstens eine Instanz haben kann, wodurch die Instanz eindeutig ist (eine Instanz verweist auf einen Objektzeiger), zum Beispiel: Zählen der Anzahl der Personen, die online sind

In der Singleton-Klasse ist sie in Lazy Style und Hungry Style unterteilt. Der Unterschied zwischen ihnen liegt in der Zeit beim Erstellen der Instanz:

1. Lazy-Stil: bedeutet, dass die Instanz nach der Ausführung des Codes nicht existiert und nur bei Bedarf erstellt wird (gilt für einzelne Threads).
2. Hungriger Stil: bedeutet, dass die Instanz bereits vorhanden ist, sobald der Code ausgeführt wird. Rufen Sie sie bei Bedarf einfach direkt auf (gilt für Multithreading).

Verwendung

1. Setzen Sie das Zugriffsattribut des Konstruktors auf privat.
2. Stellen Sie eine statische Member-Funktion GetInstance() bereit, die Benutzern nur Zugriff auf eine einzelne Instanz gewähren kann.
3. Definieren Sie einen statischen Mitgliedszeiger, den Benutzer abrufen können
4. Überladen Sie den Zuweisungsoperator (=) und den Kopierkonstruktor und setzen Sie sie auf privat, um das Kopieren zwischen Objekten zu vermeiden.

Eine vorläufige Untersuchung der Singleton-Klasse im Lazy-Stil:

#include <iostream>
using namespace std;

class CSingleton
{
private:
    static CSingleton* m_pInstance;

    CSingleton()     //构造函数为private
    {
    }

    CSingleton& operator = (const CSingleton& t);
    CSingleton(const CSingleton &);
public:
    static CSingleton* getInstance()
    {
       if(m_pInstance==NULL)
           m_pInstance= new CSingleton();

        return m_pInstance;
    }

    void print()
    {
      cout<<this<<endl;
    }
};

CSingleton* CSingleton::m_pInstance = NULL;

int main()
{
    CSingleton *p1=CSingleton::getInstance();
    CSingleton *p2=CSingleton::getInstance();
    CSingleton *p3=CSingleton::getInstance();

    p1->print();
    p2->print();
    p3->print();

　　　　return 0;
}

Druck ausführen:

0x6e2d18
0x6e2d18
0x6e2d18

Aus den Druckergebnissen ist ersichtlich, dass die Zeigerobjekte alle auf dieselbe Adresse zeigen, was bedeutet, dass eine Klasse höchstens eine Instanz haben kann.

Hinweis: Da die Instanz während des Systemlebenszyklus vorhanden ist, ist ein Löschen nicht erforderlich, solange das System noch läuft.

Wenn im obigen Lazy-Stil mehrere Csingleton-Zeigerobjekte gleichzeitig die Memberfunktion getInstance() in einer Multithread-Situation aufrufen, werden mehrere Instanzen erstellt, da m_pInstance = NULL ist.

Daher ist es im Fall von Multithreading erforderlich, zur Implementierung Hungry Man zu verwenden

Code wie folgt anzeigen:

class CSingleton
{
private:

    static CSingleton* m_pInstance;

    CSingleton()     //构造函数为private
    {
    }

    CSingleton& operator = (const CSingleton& t);
    CSingleton(const CSingleton &);

public:
    static CSingleton* getInstance()
    {
        return m_pInstance;
    }
};

CSingleton* CSingleton::m_pInstance = new CSingleton;

Singleton-Klassenvorlage

Was wir jetzt erklären, ist nur ein Framework. Es enthält nichts und kann die Anforderungen nicht erfüllen. Daher müssen wir es als Headerdatei für eine Singleton-Klassenvorlage schreiben. Wenn eine Singleton-Klasse benötigt wird, deklarieren Sie einfach die Singleton-Klassenvorlage Header-Datei direkt.

Schreiben Sie CSingleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

template <typename T>
class CSingleton
{
private:
    static T* m_pInstance;

    CSingleton()     //构造函数为private
    {
　　　　 }

public:
    static T* getInstance()
    {
        return m_pInstance;
    }
};

template <typename T>
T* CSingleton<T> :: m_pInstance = new T;

#endif

Wenn wir diese Singleton-Klassenvorlage benötigen, müssen wir sie nur als Freund über Freund in unserer eigenen Klasse hinzufügen.

Probieren Sie als Nächstes die Singleton-Klassenvorlage aus

Schreiben Sie main.cpp

#include <iostream>
#include <string>
#include "CSingleton.h"

using namespace std;

class Test
{
    friend class CSingleton<Test> ; //声明Test的友元为单例类模板
private:
    string mstr;

    Test(): mstr("abc")
    {
    }

    Test& operator = (const Test& t);
    Test(const Test&);

public:
    void Setmstr(string t)
　　　　{
     mstr=t;
　　　　}

    void print()
    {
    cout<<"mstr = "<<mstr<<endl;
    cout<<"this = "<<this<<endl;
    }
};

int main()
{
    Test *pt1 = CSingleton<Test>::getInstance();
    Test *pt2 = CSingleton<Test>::getInstance();

    pt1->print();
    pt2->print();

    pt1->Setmstr("ABCDEFG");
    pt2->print();

    return 0;
}

mstr = abc
this = 0x2d2e30

mstr = abc
this = 0x2d2e30

mstr = ABCDEFG
this = 0x2d2e30

Das Obige ist eine detaillierte Erklärung und Integration der vom Herausgeber eingeführten C++-Singleton-Klassenvorlagen. Ich hoffe, es wird Ihnen hilfreich sein.

Nachdruck von: Weidian Reading    https://www.weidianyuedu.com