Com es fa el patró de disseny de Singleton en C ++: 9 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

Introducció:

El propòsit d’aquesta guia d’instruccions és ensenyar a l’usuari com implementar el patró de disseny de singleton al seu programa C ++. En fer-ho, aquest conjunt d’instruccions també explicarà al lector per què els elements d’un singleton són com són i com es processa el codi. Saber-ho us ajudarà en el futur a depurar els vostres futurs singletons. Quin és el patró de disseny de singleton? El patró de disseny de singleton és un patró de disseny on el codificador crea una classe que només es pot crear una instància, les funcions públiques de les classes es poden accedir bàsicament a qualsevol lloc, sempre que hagis #inclòs el fitxer de capçalera en altres fitxers relacionats amb el projecte.

El patró de disseny de singleton és un patró de disseny imprescindible per a qualsevol programador orientat a objectes, programadors de programari i programadors de jocs. El patró de disseny singleton també és un dels patrons de disseny de codificació més fàcils. Aprendre-la us pot ajudar a aprendre altres patrons de disseny més difícils en el futur. També us pot ajudar a racionalitzar el codi del programa de maneres que no creieu possible.

Tot i que la dificultat del patró de disseny singleton és fàcil en comparació amb altres patrons de disseny, aquest conjunt d’instruccions té una dificultat mitjana. Això significa que, per fer aquestes instruccions, us recomanem que conegueu els requisits bàsics i avançats de sintaxi de C ++. També heu de conèixer l’etiqueta adequada de codificació C ++ (és a dir, mantenir privades les variables de classe, una classe per fitxer de capçalera, etc.). També heu de saber alliberar memòria i com funcionen els constructors i destructors a C ++.

Aquesta guia d’instruccions trigarà de mitjana uns 10-15 minuts.

Requisits materials:

-Un ordinador (pot ser PC o Mac) capaç d'executar Visual Studios (qualsevol versió)

-Un programa senzill, creat a Visual Studios, amb el qual podeu provar el vostre singleton

Nota: El patró de disseny de singleton es pot fer en qualsevol altra interfície de codificació o IDE compatible amb C ++, però per a aquest conjunt d’instruccions utilitzarem Visual Studios Enterprise Edition.

Pas 1: creeu la vostra classe, amb fitxer de capçalera i fitxer CPP

Per crear aquests dos fitxers i la classe alhora, obriu el vostre projecte / programa a Visual Studios, aneu a l'explorador de solucions, feu clic amb el botó dret i apareixerà un quadre a prop del cursor del ratolí, cerqueu l'opció "Afegeix", passeu el cursor a sobre, i apareixerà un altre quadre a la dreta. En aquest quadre, voleu trobar l’opció “Element nou..”, fer-hi clic i apareixerà una finestra que s’assembli a la imatge 1.1 de la imatge següent. En aquesta finestra voleu seleccionar "Classe C ++" i després premeu "Afegeix". S'obrirà una altra finestra que s'assembla a la imatge de la foto 1.2. En aquesta finestra, escriviu el nom de la vostra classe al camp "Nom de la classe" i Visual Studios anomenarà automàticament el fitxer real després del nom de la classe. Amb aquesta finalitat, anomenarem la nostra classe "EngineDebugSingleton", però pot ser qualsevol nom basat en lletres. Ara podeu prémer "D'acord" i continuar amb el pas 2.

Nota: L'explorador de solucions i els llocs on es conserven els fitxers a l'ordinador estan separats. Moure o crear qualsevol cosa a l’explorador de solucions no mourà ni organitzarà els fitxers dins del vostre explorador de fitxers del sistema operatiu. Una manera segura d’organitzar els fitxers al costat de l’explorador de fitxers seria eliminar, però no suprimir els fitxers específics de l’explorador de solucions, moure els mateixos fitxers a l’explorador de fitxers a la ubicació desitjada i tornar a Explorador de solucions, feu clic amb el botó dret, cerqueu l'opció "Afegeix", després cerqueu "Element existent" i cerqueu els fitxers que heu mogut. Assegureu-vos de moure tant el fitxer de capçalera com el de cpp.

Pas 2: definiu el constructor com a Privat

Amb el fitxer CPP i el fitxer de capçalera acabats de crear, si no es va obrir automàticament quan el vau crear, aneu a l’explorador de solucions i feu clic i obriu el "EngineDebugSingleton.h". A continuació, us rebrà un "EngineDebugSingleton ()", el constructor per defecte de la classe i "~ EngineDebugSingleton ()" el destructor de la classe. Per a aquest pas, voldrem establir el constructor a privat, això vol dir que aquesta funció només està disponible per a la classe i res més. Amb això, no podreu crear una variable ni assignar la classe a la memòria fora de la classe, només al fitxer de capçalera de les classes i a les altres funcions de les classes. Tenir el constructor privat és clau per al patró de disseny i el funcionament dels singletons. Descobrirem en els passos futurs com s’instancia i s’accedeix a un singleton.

Ara la classe hauria de ser així després de moure el constructor a privat (Mireu la foto associada)

Pas 3: definiu el Destructor com a Privat

Com vam fer amb el constructor de

pas 2, per a aquest pas, establirem ara el destructor com a privat. Igual que amb el constructor, res, excepte la mateixa classe, no podrà suprimir de la memòria cap variable de la classe.

Ara la classe hauria de ser així després de completar aquest pas. (Veure foto associada)

Pas 4: Creació d'una variable de punter estàtic a Singleton

En aquest pas, crearem un fitxer

variable de punter estàtic del tipus "EngineDebugSingleton *". Aquesta serà la variable que s'utilitzarà per assignar el nostre singleton a la memòria i l'assenyalarà durant tot el temps que el nostre singleton s'assigni a la memòria.

Així hauria de ser el nostre fitxer de capçalera després de crear aquesta variable

Pas 5: creació d'una funció d'instància

Ara volem fer una instància

funció. La funció haurà de ser una funció estàtica i voldrà retornar una referència a la nostra classe ("EngineDebugSingleton &"). Vam anomenar la nostra funció Instance (). A la mateixa funció, voldrem provar primer si ptrInstance == nullptr (es pot escurçar a! PtrInstance), si és nullptr, això vol dir que el singleton no s'ha assignat i, en l'àmbit de la sentència if, vull assignar fent ptrInstance = new EngineDebugSingleton (). Aquí és on realment assigneu el singleton a la memòria. Després de sortir de l’abast de la sentència if, retornarem a què apunta ptrInstance, que es denota amb la sintaxi “* ptrInstance”. Utilitzarem molt aquesta funció quan fem les nostres funcions públiques estàtiques, de manera que podem comprovar si el singleton s’ha creat i assignat a la memòria. En essència, aquesta funció fa que pugueu tenir només una assignació de la classe i no més.

Així hauria de ser la nostra classe ara després de crear la funció Instance (). Com podeu veure, tot el que hem fet s’ha quedat a la secció privada de la classe; això canviarà una mica en els propers passos.

Pas 6: Creació de funcions públiques estàtiques

Després d’haver fet la funció

pas 5, podeu començar a fer funcions públiques estàtiques. Totes les funcions públiques haurien de tenir una funció privada, el nom d'aquesta funció no pot ser el mateix. Per què la funció és estàtica? Estem fent que les funcions públiques siguin estàtiques perquè s’hi pugui accedir sense un objecte real. Per tant, en lloc de fer alguna cosa com "EngineDebugSingleObj-> SomeFunction ()", fem "EngineDebugSingleton:: Some Function ()". Això fa que es pugui accedir a un singleton bàsicament a qualsevol lloc del codi, sempre que hagis #inclòs el fitxer de capçalera al fitxer de projecte específic amb què treballis. Amb això, també podeu crear el singleton mitjançant qualsevol de les seves funcions públiques.

Als nostres propòsits, en aquest pas hem creat dues funcions de buit estàtic públic, "add ()" i "restar ()". A la secció privada, tenim dues funcions més, "PrivAdd ()" i "PrivSubtract ()". També hem afegit una variable int anomenada "NumberOfThings". La definició d’aquestes funcions entrarà al fitxer CPP de les nostres classes. Per fer que la funció entri fàcilment al fitxer CPP, ressalteu amb el cursor la funció, que hauria de tenir una línia verda a sota i premeu "ALT esquerre + ENTRAR", us donarà l'opció de crear la definició a la fitxer CPP associat a les classes. Consulteu la foto 6.1 per veure com hauria de ser el fitxer de capçalera i, després de crear totes les definicions de funcions, el CPP hauria d’assemblar-se a la foto 6.2, tret que les definicions de funcions no tinguin cap codi.

Ara voldreu afegir el mateix codi que a la foto 6.2 a les definicions de la vostra funció. Com s’ha dit anteriorment, les nostres funcions públiques faran ús de la funció Instance (), que retornarà a allò que apunta ptrInstance. Això ens permet accedir a les funcions privades de la nostra classe. Amb la funció pública de qualsevol singleton, només hauríeu de trucar a aquesta funció d’instància. L'única excepció a això és la nostra funció Finalitzar.

Nota: Les funcions públiques i privades exactes que es mostren en aquest pas no són necessàries, podeu tenir diferents noms de funcions i operacions a la funció privada, però per a qualsevol tipus de funció pública, haureu de tenir una funció privada per acompanyar-la i la funció pública sempre ha d’utilitzar, en el nostre cas, la funció Instance ().

Pas 7: creació de la funció de finalització

Com que només podem repartir la memòria individual de la nostra classe, hem de crear una funció pública estàtica. Aquesta funció cridarà delete a ptrInstance, que crida al destructor de la classe i després voldrem tornar a establir ptrInstance a nullptr perquè es pugui assignar de nou si el programa no finalitza. També voldreu finalitzar els vostres Singletons per netejar qualsevol memòria assignada que hàgiu assignat a les variables privades de qualsevol Singleton.

Pas 8: Configuració de PtrInstance a Nullptr

Per completar el vostre singleton, voleu anar al fitxer EngineDebugSingleton. CPP i, a la nostra instància, escriviu "EngineDebugSingleton * EngineDebugSingleton:: ptrInstance = nullptr" a la part superior del fitxer CPP.

Si feu això, inicialment s'establirà ptrInstance a nullptr, de manera que, quan passeu per primera vegada per la funció d'instància per primera vegada, es permetrà assignar la nostra classe a la memòria. Sense ell, és probable que obtingueu un error perquè intentareu accedir a memòria que no hi té res assignat.

Pas 9: prova i conclusió

Ara voldrem provar que el nostre singleton per assegurar-nos que funciona, això implicarà que truquem a les funcions públiques com es descriu al pas 6 i us recomanem que configureu punts d’interrupció per passar el vostre codi i comproveu que el singleton funciona com hauria de ser. El nostre punt de partida estarà a main.cpp del nostre projecte i ara main.cpp sembla la imatge següent.

Enhorabona! Acabeu de completar la vostra primera implementació del patró de disseny Singleton. Amb aquest patró de disseny, ara podeu racionalitzar el vostre codi de diverses maneres. Per exemple, ara podeu crear sistemes de gestor que funcionin durant el temps d'execució del programa, als quals es pot accedir mitjançant funcions estàtiques des de qualsevol lloc on hàgiu inclòs la classe.

El fitxer de capçalera final hauria de semblar a la foto 7.1. El fitxer CPP associat del vostre singleton hauria de ser similar a la foto 6.2 amb l’addició, a la part superior del fitxer, del codi que es mostra al pas 8. Aquesta instrucció us proporcionava una estructura senzilla del patró de disseny de Singleton.

Consells de resolució de problemes:

Voleu obtenir errors relacionats amb la memòria?

Assegureu-vos que consulteu els passos 7 i 8 per assegurar-vos que esteu configurant ptrInstance a nullptr.

Es produeix un bucle infinit?

Assegureu-vos que per a les funcions públiques, en les seves definicions, esteu cridant la funció privada, no la mateixa funció pública.

Els objectes assignats dins del singleton causen fuites de memòria?

Assegureu-vos de trucar a la funció de finalització del vostre singleton quan correspongui dins del codi del programa i, al destructor del vostre singleton, assegureu-vos de desassignar els objectes assignats a la memòria dins de l’abast del codi singleton.