Az egyszemélyes mintát általában akkor használják, ha egyetlen, megosztott erőforrásra van szüksége, amelyhez globálisan kell hozzáférni, például adatbázis-kapcsolathoz, naplózóhoz vagy konfigurációkezelőhöz. Egyetlen példány kényszerítésével lehetővé teszi a program több része számára, hogy hozzáférjenek és módosítsák ugyanazt az objektumot, elősegítve az adatok konzisztenciáját és csökkentve a globális változók szükségességét. A Singleton objektum-gyorsítótárként használható, ahol a gyakran használt vagy költségesen létrehozható objektumokat tárolják és újra felhasználják az alkalmazás során. Ez a megközelítés segít a teljesítmény javításában azáltal, hogy elkerüli a redundáns objektumok létrehozását és inicializálását.
Ebben a cikkben elmagyarázzuk a szingulett létrehozását, és bemutatunk egy példát a szinglihangok stilizálására egy C++ programban.
1. példa: Egyszerű szingleton létrehozása lelkes inicializálással
A korai inicializálással rendelkező egyszerű szingli olyan tervezési minta, amely biztosítja, hogy egy osztálynak csak egy példánya kerüljön létrehozásra, és ez szívesen jön létre a statikus inicializálás során.
Bemutatjuk az alapvető kódrészletet egy egyszerű szingli létrehozásához, lelkes inicializálással. Kezdjük a programmal:
#include
osztályú Singleton {
magán :
statikus Szingli * példa ;
Szingli ( ) { }
nyilvános :
statikus Szingli * getInstance ( ) {
Visszatérés példa ;
}
} ;
Szingli * Szingli :: példa = új Singleton ( ) ;
int fő- ( ) {
Szingli * singletonInstance1 = Szingli :: getInstance ( ) ;
Szingli * singletonInstance2 = Szingli :: getInstance ( ) ;
std :: cout << 'singletonletonInstance1: ' << singletonInstance1 << std :: endl ;
std :: cout << 'singletonletonInstance2: ' << singletonInstance2 << std :: endl ;
Visszatérés 0 ;
}
A kód tartalmazza az
A fejlécfájl hozzáadása után definiáljuk az „Singleton” osztályt, amely a singleton minta megvalósítását képviseli. Van egy privát konstruktora és egy „példány” nevű privát statikus tagváltozója.
Ezután a getInstance() függvény a „Singleton” osztály nyilvános statikus tagfüggvényeként valósul meg. A statikus tagváltozópéldányban tárolt singleton példányát adja vissza. A statikus tagváltozópéldány az osztályon kívül a következővel van meghatározva és inicializálva: „Singleton* Singleton::instance = new Singleton();”. Ez a sor lelkesen inicializálja a „Singleton” osztály példányát a statikus inicializálás során.
A main() függvényben két mutatót deklarálunk, a „singletonInstance1” és a „singletonInstance2”, és hozzárendeljük a Singleton::getInstance() meghívásával visszaadott értéket. Mivel a példányt lelkesen inicializálják, mindkét mutató ugyanarra a példányra mutat. Az „std::cout” utasítások kiírják a „singletonInstance1” és „singletonInstance2” memóriacímét a konzolra a „<<” operátor és „std::endl” használatával.
A kód „0-val” végződik, ami a program sikeres végrehajtását jelzi.
Amikor ezt a kódot futtatja, a kimenet valami ilyesmi lesz:
A kimenet megjeleníti a „singletonInstance1” és „singletonInstance2” memóriacímeket. Mivel mindkét mutató ugyanahhoz a példányhoz van hozzárendelve, amely a Singleton::getInstance() függvényből származik, ugyanaz a memóriacímük. Ez bemutatja, hogy a singleton minta hogyan garantálja, hogy az osztály egyetlen példánya legyen, és hogy a getInstance() jövőbeli hívásai mindig ugyanazt a példányt eredményezik.
2. példa: Singleton Pattern implementáció lusta inicializálással
Ez a demonstráció elmagyarázza a singleton minta megvalósítását lusta inicializálással, és bemutatja annak használatát a main() függvényben. A kódrészlet lépésről lépésre történő magyarázata a program után található:
#includeosztályú Singleton {
magán :
statikus Szingli * példa ;
Szingli ( ) {
std :: cout << 'Singleton példány létrehozva.' << std :: endl ;
}
nyilvános :
statikus Szingli * getInstance ( ) {
ha ( példa == nullptr ) {
példa = új Singleton ( ) ;
}
Visszatérés példa ;
}
üres showMessage ( ) {
std :: cout << – Üdvözlet Singletonból! << std :: endl ;
}
~Singleton ( ) {
std :: cout << 'Singleton példány megsemmisült.' << std :: endl ;
}
} ;
Szingli * Szingli :: példa = nullptr ;
int fő- ( ) {
Szingli * singletonInstance1 = Szingli :: getInstance ( ) ;
singletonInstance1 -> showMessage ( ) ;
Szingli * singletonInstance2 = Szingli :: getInstance ( ) ;
singletonInstance2 -> showMessage ( ) ;
Visszatérés 0 ;
}
A program a bemeneti/kimeneti feladatok végrehajtásához az
Amikor a „Singleton” osztály konstruktorát hívják, az létrehoz egy példányt a „Singleton” osztályból. A „Singleton példány létrehozva” üzenetet adja ki a konzolnak az „std::cout << … << std::endl;” használatával. A konstruktornak nincsenek paraméterei, mivel ez egy alapértelmezett konstruktor. Singleton()-ként van megadva argumentumok nélkül. Privátnak nyilvánítjuk, ami azt jelenti, hogy csak az osztályon belülről hívható meg. Ez megakadályozza a „Singleton” osztály közvetlen példányosítását, és biztosítja, hogy a példány beszerzésének egyetlen módja a getInstance() függvény.
A „Singleton” osztály getInstance() metódusa nyilvános statikus tagfüggvényként van deklarálva. Az a szerepe, hogy létrehozza és hozzáférést biztosít az egyetlen példányhoz. A getInstance() függvényben ellenőrzi, hogy a példány „nullptr”-e. Ha igen, ami azt jelzi, hogy a példány még nincs jelen, akkor a privát konstruktort használja a „Singleton” osztály új objektumának példányosítására.
A showMessage() függvény egy egyszerű tagfüggvény, amely a „Hello from Singleton!” üzenetet jeleníti meg. üzenet. A singleton destruktora definiált. Implicit módon akkor hívják, amikor a program leáll, és kiírja a „Singleton példány megsemmisült” üzenetet. üzenet, amely azt jelzi, hogy a singleton példány megsemmisült. A statikus tagváltozópéldány kezdetben „nullptr”-ként van meghatározva.
Az int main() elindítja a main() függvény definícióját. Ezután a „Singleton* singletonInstance1 = Singleton::getInstance();” meghívja a „Singleton” osztály getInstance() függvényét, hogy mutatót kapjon a singleton példányra. Ezt a mutatót a „singletonInstance1” változóhoz rendeli.
Ezt követően a „singletonInstance1->showMessage();” a nyíl operátort (->) használja a showMessage() függvény meghívásához a „singletonInstance1” mutatón. Ez a funkció megjeleníti a benne megadott üzenetet a konzolon. Ezt követően a „Singleton* singletonInstance2 = Singleton::getInstance();” ismét meghívja a getInstance() függvényt, és egy másik mutatót kap az egyszeres példányra. Ezúttal a mutatót a „singletonInstance2” változóhoz rendeli. A 'singletonInstance2->showMessage();' meghívja a showMessage() függvényt a „singletonInstance2” mutatón. Ez a funkció megjeleníti a „Hello from Singleton!” üzenetet. ismét üzenetet küld a konzolnak.
Végül: „0;” a main() függvény végét jelenti, és a program 0 értéket ad vissza, ami a program sikeres végrehajtását jelzi.
Íme a korábban kifejtett kódrészlet kimenete:
Ez az eredmény megerősíti, hogy a „Singleton” osztály csak egy példány létrehozását biztosítja, és a getInstance() függvény további hívásai megbízhatóan ugyanazt a példányt eredményezik.
Következtetés
A szingli létrehozása C++ nyelven nagyon hasznos fogalom. Ebben a bejegyzésben kezdetben a singleton bevezetésével foglalkoztunk. Továbbá két példa készült a szingli C++ nyelvben való megvalósítására. Az első ábra a lelkes singleton inicializálás megvalósítását mutatja be. Míg az egytagú minta lusta inicializálását a cikk második példája tartalmazza. Sőt, az előállított kimenet pillanatképei is megjelennek a megfelelő programok számára.