Hoe om die Singleton -ontwerppatroon in C ++ te doen: 9 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Inleiding:

Die doel van hierdie instruksiesgids is om die gebruiker te leer hoe om die singleton -ontwerppatroon in hul C ++ - program te implementeer. Deur dit te doen, sal hierdie instruksiestel ook aan die leser verduidelik waarom elemente van 'n enkelbrood soos dit is en hoe die kode verwerk word. As u dit weet, sal dit in die toekoms help om u toekomstige enkellopers te ontfout. Wat is die singleton -ontwerppatroon? Die singleton -ontwerppatroon is 'n ontwerppatroon waar die kodeerder 'n klas skep wat slegs een keer geïnstalleer kan word, en die openbare funksies van die klasse kan basies oral verkry word, mits u die opskriflêer in ander projekverwante lêers ingesluit het.

Die ontwerp-patroon van singleton is 'n onontbeerlike ontwerppatroon vir enige objekgeoriënteerde programmeerder, sagteware-programmeerders en spelprogrammeerders. Die singleton -ontwerppatroon is ook een van die maklikste koderingsontwerppatrone wat daar is. As u dit leer, kan u in die toekoms ander, moeiliker ontwerppatrone leer. Dit kan u ook help om die kode van u program te stroomlyn op maniere wat u nie gedink het moontlik was nie.

Alhoewel die moeilikheidsgraad van die singleton -ontwerppatroon maklik is in vergelyking met ander ontwerppatrone, het hierdie instruksiestel 'n medium moeilikheidsgraad. Dit beteken dat ons, om hierdie instruksies uit te voer, aanbeveel dat u basiese en voorgeskrewe sintaksisvereistes van C ++ ken. U moet ook die regte C ++ - koderingetiket ken (dws Hou klasveranderlikes privaat, een klas per koplêer, ens.). U moet ook weet hoe u geheue kan bevry en hoe konstrukteurs en vernietigers in C ++ werk.

Hierdie instruksies sal gemiddeld ongeveer 10-15 minute neem.

Materiaalvereistes:

-'n Rekenaar (kan 'n rekenaar of 'n Mac wees) wat Visual Studios kan bestuur (enige weergawe)

-'n Eenvoudige program, geskep in Visual Studios, waarmee u u enkel kan toets

Opmerking: die enkelontwerppatroon kan op enige ander C ++ IDE- of koderingskoppelvlak gedoen word, maar vir hierdie instruksieset gebruik ons Visual Studios Enterprise Edition.

Stap 1: Skep u klas, met opskriflêer en CPP -lêer

Om hierdie twee lêers en die klas gelyktydig te skep, maak u projek / program oop in Visual Studios, gaan na die oplossingverkenner, klik met die rechtermuisknop, en 'n blokkie verskyn naby u muiswyser, vind die opsie 'Voeg', beweeg daaroor, en 'n ander blokkie moet regs verskyn. In hierdie boks wil u die opsie "Nuwe item.." vind, klik daarop en 'n venster, wat lyk soos die foto 1.1 hieronder, verskyn. In hierdie venster wil u 'C ++ Class' kies en dan op 'Add' klik. Dit sal 'n ander venster oopmaak wat lyk soos die foto 1.2 -prent. Tik in hierdie venster die naam van u klas in die veld "Klasnaam" en Visual Studios sal die werklike lêer outomaties na die klasnaam noem. Vir die doel van hierdie instruksie, gaan ons ons klas 'EngineDebugSingleton' noem, maar dit kan enige lettergebaseerde naam wees. U kan nou "OK" druk en na stap 2 gaan.

Let wel: die oplossingverkenner en waar die lêers op u rekenaar gehou word, is apart. As u iets in die oplossingverkenner skuif of skep, word die lêers in u OS -lêerverkenner nie verplaas of georganiseer nie. 'N Veilige manier om u lêers aan die kant van die lêerverkenner te organiseer, is om die spesifieke lêers uit die oplossingverkenner te verwyder, maar nie die spesifieke lêers te verwyder nie, skuif dieselfde lêers in die lêerverkenner na die gewenste plek en gaan dan terug na oplossingverkenner, klik met die rechtermuisknop, vind die opsie "Voeg by", vind dan "Bestaande item" en vind die lêers wat u verskuif het. Maak seker dat u beide die kop- en cpp -lêer skuif.

Stap 2: Stel die Constructor op Private

As dit met u nuutgeskepte CPP -lêer en koplêer, as dit nie outomaties oopgemaak is toe u dit geskep het nie, gaan na die oplossingverkenner en klik en maak die "EngineDebugSingleton.h" oop. U word dan begroet met 'n "EngineDebugSingleton ()", die standaardkonstrukteur van die klas en "~ EngineDebugSingleton ()" die klasvernietiger. Vir hierdie stap wil ons die konstruktor op privaat stel, dit beteken dat hierdie funksie slegs vir die klas beskikbaar is en niks anders nie. Hiermee kan u nie 'n veranderlike maak of die klas aan geheue buite die klas toewys nie, slegs in die opskriflêer van die klasse en die ander funksies van die klasse. Om die konstrukteur privaat te hê, is die sleutel tot die ontwerppatroon en die manier waarop enkellopendes werk. Ons sal in toekomstige stappe ontdek hoe 'n enkellopie geïnstalleer en verkry word.

Die klas behoort nou so te lyk nadat die bouer na privaat verhuis is (kyk na die gepaardgaande foto)

Stap 3: Stel die Destructor in op Private

Soos ons met die bouer in

stap 2, vir hierdie stap stel ons die vernietiger nou op privaat. Soos met die konstruktor, kan niks, behalwe die klas self, enige veranderlikes van die klas uit die geheue verwyder nie.

Die klas behoort nou so te lyk nadat hierdie stap voltooi is. (Sien geassosieerde foto)

Stap 4: Skep 'n statiese wyserveranderlike in die Singleton

In hierdie stap sal ons 'n

statiese wyser veranderlike van die tipe "EngineDebugSingleton*". Dit sal die veranderlike wees wat gebruik sal word om ons enkel aan die geheue toe te ken en daarop te wys vir die hele tyd wat ons enkeling aan die geheue toegeken word.

Dit is hoe ons koplêer moet lyk nadat ons hierdie veranderlike geskep het

Stap 5: Skep 'n instansie -funksie

Ons wil nou 'n voorbeeld maak

funksie. Die funksie moet 'n statiese funksie wees en 'n verwysing na ons klas ("EngineDebugSingleton &") wil teruggee. Ons het ons funksie Instance () genoem. In die funksie self wil ons eers toets of ptrInstance == nullptr (kan verkort word na! PtrInstance), as dit nullptr is, beteken dit dat die singleton nie toegeken is nie en in die omvang van die if -verklaring, sal ons wil toewys deur ptrInstance = new EngineDebugSingleton () te doen. Dit is waar u die singleton eintlik aan die geheue toewys. Nadat ons die omvang van die if -stelling verlaat het, sal ons dan terugkeer na wat ptrInstance wys, wat aangedui word deur die sintaksis "*ptrInstance". Ons sal hierdie funksie baie gebruik wanneer ons ons statiese openbare funksies verrig, sodat ons kan kyk of die singleton geskep is en aan die geheue toegewys is. Hierdie funksie maak dit in wese so dat u slegs een klasverdeling kan hê en nie meer nie.

Dit is hoe ons klas moet lyk nadat ons die Instance () -funksie geskep het. Soos u kan sien, het alles wat ons gedoen het in die privaat afdeling van die klas gebly, dit gaan 'n bietjie verander in die volgende paar stappe.

Stap 6: Die skep van statiese openbare funksies

Nadat u die funksie gemaak het

stap 5, kan u begin om statiese openbare funksies te verrig. Elke publieke funksie moet 'n privaat funksie hê, die naam van hierdie funksie kan nie dieselfde wees nie. Waarom die funksie staties maak? Ons maak die openbare funksies staties, sodat dit sonder 'n werklike voorwerp verkry kan word. Dus in plaas daarvan om iets soos "EngineDebugSingleObj-> SomeFunction ()" te doen, doen ons "EngineDebugSingleton:: Some Function ()". Dit maak dit moontlik om toegang tot 'n enkelspel te verkry, oral in die kode, mits u die koptekstlêer #ingesluit het in die spesifieke projeklêer waarmee u werk. Hiermee kan u ook die enkelspel deur enige van die openbare funksies daarvan skep.

Vir ons doeleindes het ons in hierdie stap twee openbare statiese leemtefunksies geskep, "optel ()" en "aftrek ()". In die privaat afdeling het ons nog twee funksies, "PrivAdd ()" en "PrivSubtract ()". Ons het ook 'n int -veranderlike bygevoeg met die naam "NumberOfThings". Die definisie vir hierdie funksies gaan in die CPP -lêer van ons klasse. Om die funksie maklik in die CPP -lêer te laat beland, merk u met u wyser die funksie, met 'n groen lyn onder, en druk op "ALT + ENTER links". Dit gee u die opsie om die definisie in die klasse se verwante CPP -lêer. Sien foto 6.1 om te sien hoe die koplêer moet lyk en nadat u al die funksie -definisies gemaak het, moet u CPP soos foto 6.2 lyk, behalwe dat u funksie -definisies geen kode bevat nie.

U sal nou dieselfde kode as in Foto 6.2 by u funksie -definisies wil voeg. Soos vroeër gesê, gebruik ons openbare funksies die Instance () -funksie, wat sal teruggee waarop ptrInstance verwys. Dit gee ons toegang tot die privaat funksies van ons klas. Met die openbare funksie van enige enkelman, moet u slegs die instansie -funksie noem. Die enigste uitsondering hierop is ons beëindigingsfunksie.

Nota: die presiese openbare en privaat funksies wat in hierdie stap getoon word, is nie nodig nie; u kan verskillende funksiename en bedrywighede in die privaat funksie hê, maar vir enige soort openbare funksie moet u 'n privaat funksie hê. die openbare funksie moet in ons geval altyd die Instance () -funksie gebruik.

Stap 7: Skep die beëindigingsfunksie

Aangesien ons slegs ons enkel uit ons geheue in ons klas kan plaas, moet ons 'n statiese openbare funksie skep. Hierdie funksie noem delete op ptrInstance, wat die klasvernietiger noem, en dan wil ons ptrInstance terugstel na nullptr, sodat dit weer toegeken kan word as u program nie eindig nie. U wil ook u Singletons beëindig om enige toegewysde geheue wat u in die private veranderlikes van Singleton toegeken het, op te ruim.

Stap 8: Stel PtrInstance in op Nullptr

Om u enkel te voltooi, gaan u na EngineDebugSingleton. CPP -lêer en tik in ons geval "EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr."

As u dit doen, sal ptrInstance aanvanklik op nullptr gestel word, dus as u die instansie -funksie vir die eerste keer deurgaan, word ons klas toegelaat om aan die geheue toegeken te word. Daarsonder sal u heel waarskynlik 'n fout kry, want u sal probeer om toegang te verkry tot geheue wat niks daaraan toegewys is nie.

Stap 9: Toets en gevolgtrekking

Ons sal nou wil toets dat ons enkellopend om seker te maak dat dit werk, dit sal behels dat ons die openbare funksies bel soos beskryf in stap 6 en ons beveel aan dat u breekpunte opstel om deur u kode te kyk en te sien dat die singleton werk soos dit moet wees. Ons beginpunt is in ons projek se main.cpp en ons main.cpp lyk nou soos in die onderstaande prentjie.

Baie geluk! U het pas u eerste implementering van die Singleton -ontwerppatroon voltooi. Met hierdie ontwerppatroon kan u u kode nou op verskillende maniere vaartbelyn maak. U kan byvoorbeeld bestuurderstelsels maak wat gedurende u program se werktyd werk, en u kan dit via statiese funksies kry waar u ook al die klas ingesluit het.

Jou finale koplêer moet soos die foto 7.1 lyk. Die geassosieerde CPP -lêer van u singleton moet soos foto 6.2 lyk, met die byvoeging van bo -aan die lêer van die kode in stap 8. Hierdie instruksie het u 'n eenvoudige struktuur van die Singleton -ontwerppatroon gegee.

Advies oor probleemoplossing:

Kry u geheueverwante foute?

Maak seker dat u na stap 7 en stap 8 verwys om seker te maak dat u ptrInstance op nullptr stel.

Kom daar oneindige lus voor?

Maak seker dat u vir die openbare funksies die privaat funksie in hul definisies noem, nie dieselfde openbare funksie nie.

Voorwerpe wat binne die enkeling toegeken word, veroorsaak dat geheue lek?

Maak seker dat u die beëindigingsfunksie van u singleton bel, indien toepaslik binne u programkode, en in die vernietiger van u singleton, maak seker dat u alle voorwerpe wat binne die omvang van die singletonkode aan die geheue toegewys is, deeltalliseer.