Jak vytvořit Singleton v C++

Jak Vytvorit Singleton V C



V C++ je singleton principem návrhu, který zajišťuje přítomnost osamocené instance třídy v celém programu a poskytuje globální přístupový bod k této konkrétní instanci.

Vzor singleton se běžně používá, když potřebujete mít jeden sdílený prostředek, ke kterému by měl být přístup globálně, jako je připojení k databázi, logger nebo správce konfigurace. Vynucením jedné instance umožňuje více částem programu přistupovat ke stejnému objektu a upravovat jej, čímž podporuje konzistenci dat a snižuje potřebu globálních proměnných. Singleton lze použít jako mezipaměť objektů, kde jsou často používané nebo nákladné objekty ukládány a opakovaně používány v celé aplikaci. Tento přístup pomáhá zlepšit výkon tím, že se vyhne vytváření a inicializaci nadbytečných objektů.

V tomto článku si vysvětlíme vytvoření singletonu a předvedeme příklad stylizace singletonu v programu C++.







Příklad 1: Vytvoření jednoduchého Singletonu s Eager Initialization

Jednoduchý singleton s časnou inicializací je návrhový vzor, ​​který zajišťuje, že je vytvořena pouze jedna instance třídy, a ta se vytváří dychtivě během statické inicializace.



Předvedeme si základní úryvek kódu pro vytvoření jednoduchého singletonu s dychtivou inicializací. Začněme programem:



#include

třídy Singleton {
soukromé :
statický jedináček * instance ;
jedináček ( ) { }
veřejnost :
statický jedináček * getInstance ( ) {
vrátit se instance ;
}
} ;


jedináček * jedináček :: instance = nový Singleton ( ) ;

int hlavní ( ) {

jedináček * singletonInstance1 = jedináček :: getInstance ( ) ;

jedináček * singletonInstance2 = jedináček :: getInstance ( ) ;

std :: cout << 'singletonletonInstance1: ' << singletonInstance1 << std :: endl ;

std :: cout << 'singletonletonInstance2: ' << singletonInstance2 << std :: endl ;

vrátit se 0 ;

}

Kód obsahuje hlavičku , která poskytuje funkce pro práci se vstupními a výstupními proudy, jako je „std::cout“.





Po zahrnutí hlavičkového souboru definujeme třídu „Singleton“, která představuje implementaci vzoru singleton. Má soukromý konstruktor a soukromou statickou členskou proměnnou s názvem „instance“.

Poté je funkce getInstance() implementována jako veřejná statická členská funkce třídy „Singleton“. Vrátí instanci singletonu, která je uložena v instanci statické členské proměnné. Instance statické členské proměnné je definována a inicializována mimo třídu pomocí „Singleton* Singleton::instance = new Singleton();“. Tento řádek horlivě inicializuje instanci třídy „Singleton“ během statické inicializace.



Ve funkci main() deklarujeme dva ukazatele, „singletonInstance1“ a „singletonInstance2“, a přiřadíme hodnotu, která je vrácena voláním Singleton::getInstance(). Protože je instance dychtivě inicializována, oba ukazatele ukazují na stejnou instanci. Příkazy „std::cout“ vytisknou adresy paměti „singletonInstance1“ a „singletonInstance2“ do konzole pomocí operátoru „<<“ a „std::endl“.

Kód končí „návratem 0“, což znamená úspěšné provedení programu.

Když spustíte tento kód, výstup je něco takového:

Výstup zobrazuje adresy paměti „singletonInstance1“ a „singletonInstance2“. Vzhledem k tomu, že oběma ukazatelům je přiřazena stejná instance, která se získává z Singleton::getInstance(), mají stejnou adresu paměti. To ukazuje, jak vzor singleton zaručuje, že existuje jediná instance třídy a že budoucí volání getInstance() vždy povedou ke stejné instanci.

Příklad 2: Implementace vzoru Singleton s línou inicializací

Tato ukázka vysvětluje implementaci vzoru singleton s línou inicializací a ukazuje její použití ve funkci main(). Podrobné vysvětlení fragmentu kódu je uvedeno po tomto programu:

#include

třídy Singleton {

soukromé :

statický jedináček * instance ;

jedináček ( ) {

std :: cout << 'Singleton instance vytvořen.' << std :: endl ;

}

veřejnost :

statický jedináček * getInstance ( ) {

-li ( instance == nullptr ) {

instance = nový Singleton ( ) ;

}

vrátit se instance ;

}

prázdnota showMessage ( ) {

std :: cout << 'Zdravím ze Singletonu!' << std :: endl ;

}

~Singleton ( ) {

std :: cout << 'Singletonová instance zničena.' << std :: endl ;

}

} ;

jedináček * jedináček :: instance = nullptr ;

int hlavní ( ) {

jedináček * singletonInstance1 = jedináček :: getInstance ( ) ;

singletonInstance1 -> showMessage ( ) ;

jedináček * singletonInstance2 = jedináček :: getInstance ( ) ;

singletonInstance2 -> showMessage ( ) ;

vrátit se 0 ;

}

Program začíná přidáním hlavičkového souboru k provedení vstupních/výstupních úloh. Poté deklarujeme a definujeme třídu „Singleton“. Jediná instance třídy je uchovávána v soukromé statické členské proměnné s názvem „instance“.

Kdykoli je zavolán konstruktor třídy „Singleton“, vygeneruje instanci třídy „Singleton“. Výstupem zprávy “Singleton instance created” na konzoli pomocí “std::cout << … << std::endl;”. Konstruktor nemá žádné parametry, protože se jedná o výchozí konstruktor. Je definována jako Singleton() bez jakýchkoli argumentů. Deklarujeme jej jako soukromý, což znamená, že jej lze vyvolat pouze zevnitř třídy. To zabraňuje přímé instanci třídy „Singleton“ a zajišťuje, že jediný způsob, jak získat instanci, je prostřednictvím funkce getInstance().

Metoda getInstance() třídy „Singleton“ je deklarována jako veřejná statická členská funkce. Je v roli zřízení a udělování přístupnosti singletonové instanci. Uvnitř getInstance() zkontroluje, zda je instance „nullptr“. Pokud ano, což znamená, že instance ještě není přítomna, použije soukromý konstruktor k vytvoření instance nového objektu třídy „Singleton“.

Funkce showMessage() je jednoduchá členská funkce, která zobrazuje „Hello from Singleton!“ zpráva. Je definován destruktor singletonu. Je volána implicitně, když se program ukončí a vypíše „Instanci Singleton zničena“. zpráva, která označuje, že instance singleton je zničena. Instance statické členské proměnné je zpočátku definována jako „nullptr“.

Int main() spustí definici funkce main(). Poté „Singleton* singletonInstance1 = Singleton::getInstance();“ volá funkci getInstance() třídy „Singleton“, aby získal ukazatel na instanci singletonu. Tento ukazatel přiřadí proměnné „singletonInstance1“.

Poté „singletonInstance1->showMessage();“ používá operátor šipky (->) k volání funkce showMessage() na ukazateli „singletonInstance1“. Tato funkce zobrazí konzoli zprávu, která je v ní uvedena. Poté „Singleton* singletonInstance2 = Singleton::getInstance();“ znovu zavolá funkci getInstance() a získá další ukazatel na instanci singletonu. Tentokrát přiřadí ukazatel k proměnné „singletonInstance2“. The 'singletonInstance2->showMessage();' volá funkci showMessage() na ukazateli „singletonInstance2“. Tato funkce zobrazí „Hello from Singleton!“ zprávu znovu do konzole.

Nakonec „návrat 0;“ znamená konec funkce main() a program vrátí hodnotu 0, která znamená úspěšné provedení programu.

Zde je výstup dříve vysvětleného fragmentu kódu:

Tento výsledek potvrzuje, že třída „Singleton“ zajišťuje vytvoření pouze jedné instance a že další volání funkce getInstance() spolehlivě poskytují stejnou instanci.

Závěr

Vytvoření singletonu v C++ je velmi užitečný koncept. V tomto příspěvku jsme se zpočátku zabývali úvodní částí singletonu. Dále jsou vytvořeny dva příklady pro implementaci singletonu v C++. První ilustrace ukazuje implementaci dychtivé singletonové inicializace. Zatímco implementace líné inicializace vzoru singleton je uvedena ve druhém příkladu tohoto článku. Kromě toho jsou také zobrazeny snímky vytvořeného výstupu pro odpovídající programy.