Sådan gør du Singleton -designmønsteret i C ++: 9 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

Introduktion:

Formålet med denne vejledning er at lære brugeren om, hvordan man implementerer singleton -designmønsteret i deres C ++ - program. Ved at gøre dette vil dette instruktionssæt også forklare læseren, hvorfor elementer i en singleton er, som de er, og hvordan koden behandles. At vide dette, vil i fremtiden hjælpe med fejlfinding af dine fremtidige singletons. Hvad er singleton -designmønsteret? Singleton -designmønsteret er et designmønster, hvor koderen opretter en klasse, der kun kan instantieres én gang, klassernes offentlige funktioner kan stort set fås overalt, forudsat at du har #inkluderet header -filen i andre projektrelaterede filer.

Singleton-designmønsteret er et must-kend designmønster for enhver objektorienteret programmør, software-programmører og spilprogrammører. Singleton -designmønsteret er også et af de letteste kodningsmodeller der findes. At lære det kan hjælpe dig med at lære andre, vanskeligere designmønstre i fremtiden. Det kan også hjælpe dig med at strømline dit programs kode på måder, du ikke troede var mulig.

Selvom vanskeligheden ved singleton -designmønsteret er let i sammenligning med andre designmønstre, har dette instruktionssæt en medium vanskelighed. Det betyder, at for at udføre disse instruktioner anbefaler vi, at du kender grundlæggende og forudgående syntaksekrav for C ++. Du bør også kende den korrekte C ++ kodningsetikette (dvs. Hold klassevariabler private, en klasse pr. Headerfil osv.). Du bør også vide, hvordan du frigør hukommelse, og hvordan konstruktører og destruktorer fungerer i C ++.

Denne instruktionsvejledning tager i gennemsnit omkring 10-15 minutter.

Materialekrav:

-En computer (kan være PC eller Mac) i stand til at køre Visual Studios (enhver version)

-Et enkelt program, skabt i Visual Studios, som du kan teste din singleton med

Bemærk: Singleton -designmønsteret kan udføres på alle andre C ++ - understøttende IDE- eller kodningsgrænseflader, men til dette instruktionssæt bruger vi Visual Studios Enterprise Edition.

Trin 1: Opret din klasse med overskriftsfil og CPP -fil

For at oprette disse to filer og klassen på én gang skal du åbne dit projekt / program i Visual Studios, gå over til løsningsudforskeren, højreklikke, og en boks skal dukke op nær din musemarkør, find muligheden "Tilføj", hold musen over det, og en anden boks skulle vises til højre. I denne boks vil du finde indstillingen "Nyt element..", klik på det, og et vindue, der ligner foto 1.1 -billedet herunder, skal vises. I dette vindue vil du vælge "C ++ Class" og derefter trykke på "Tilføj". Dette åbner et andet vindue, der ligner foto 1.2 -billedet. I dette vindue skriver du navnet på din klasse i feltet "Klassenavn", og Visual Studios navngiver automatisk den faktiske fil efter klassens navn. Til denne instruks formål vil vi navngive vores klasse "EngineDebugSingleton", men det kan være et hvilket som helst bogstavbaseret navn. Du kan nu trykke "OK" og fortsætte til trin 2.

Bemærk: Løsningsudforskeren, og hvor filerne opbevares på din computer, er adskilte. Flytning eller oprettelse af noget i løsningsudforskeren flytter eller organiserer ikke filerne i din OS -filudforsker. En sikker måde at organisere dine filer på filudforskersiden ville være at fjerne, men ikke slette de specifikke filer fra løsningsudforskeren, flytte de samme filer i filudforskeren til den ønskede placering og derefter gå tilbage til løsningsudforskeren, højreklik, find indstillingen "Tilføj", find derefter "Eksisterende element" og find de filer, du har flyttet. Sørg for at flytte både header- og cpp -filen.

Trin 2: Indstil konstruktøren til privat

Med din nyoprettede CPP -fil og headerfil, hvis den ikke åbnede automatisk, da du oprettede den, skal du gå til løsningsudforskeren og klikke og åbne "EngineDebugSingleton.h". Du vil derefter blive mødt med en "EngineDebugSingleton ()", klassens standardkonstruktør og "~ EngineDebugSingleton ()" klassedestruktoren. Til dette trin vil vi gerne indstille konstruktøren til det private, det betyder, at denne funktion kun er tilgængelig for klassen og intet andet. Med dette vil du ikke være i stand til at lave en variabel eller allokere klassen til hukommelse uden for klassen, kun i klassernes overskriftsfil og klassernes andre funktioner. At have konstruktøren privat er nøglen til designmønsteret og hvordan singletoner fungerer. Vi vil i fremtidige trin opdage, hvordan en singleton instantieres og tilgås.

Klassen skal nu se sådan ud efter at have flyttet konstruktøren til privat (Se tilhørende foto)

Trin 3: Indstil Destructor til Privat

Som vi gjorde med konstruktøren i

trin 2, for dette trin, vil vi nu indstille destruktoren til privat. Ligesom med konstruktøren vil intet undtagen selve klassen kunne slette eventuelle variabler i klassen fra hukommelsen.

Klassen skal nu se sådan ud efter at have gennemført dette trin. (Se tilhørende foto)

Trin 4: Oprettelse af en statisk pointervariabel i Singleton

I dette trin opretter vi en

statisk markørvariabel af typen "EngineDebugSingleton*". Dette vil være den variabel, der vil blive brugt til at tildele vores singleton til hukommelse og vil pege på den for hele den tid, vores singleton er allokeret til hukommelse.

Sådan skal vores header -fil se ud efter at have oprettet denne variabel

Trin 5: Oprettelse af en instansfunktion

Vi vil nu lave en instans

fungere. Funktionen skal være en statisk funktion og vil gerne returnere en reference til vores klasse ("EngineDebugSingleton &"). Vi kaldte vores funktion Instance (). I selve funktionen vil vi først teste, om ptrInstance == nullptr (kan forkortes til! PtrInstance), hvis det er nullptr, betyder det, at singletonen ikke er blevet tildelt, og i omfanget af if -sætningen vil vi ønsker at tildele ved at gøre ptrInstance = new EngineDebugSingleton (). Det er her, du rent faktisk allokerer singlen til hukommelsen. Efter at have forladt omfanget af if -sætningen, returnerer vi det, ptrInstance peger på, hvilket er betegnet med syntaksen "*ptrInstance". Vi vil bruge denne funktion stærkt, når vi laver vores statiske offentlige funktioner, så vi kan kontrollere, om singletonen er blevet oprettet og allokeret til hukommelse. I det væsentlige gør denne funktion det, så du kun kan have en fordeling af klassen og ikke mere.

Sådan skal vores klasse se ud nu efter oprettelse af funktionen Instance (). Som du kan se, er alt det, vi har gjort, blevet i den private sektion af klassen, dette kommer til at ændre sig lidt i de næste par trin.

Trin 6: Oprettelse af statiske offentlige funktioner

Når du har lavet funktionen fra

trin 5, kan du begynde at lave statiske offentlige funktioner. Enhver offentlig funktion skal have en privat funktion til at følge med den, navnet på denne funktion kan ikke være det samme. Hvorfor gøre funktionen statisk? Vi gør de offentlige funktioner statiske, så de kan tilgås uden et egentligt objekt. Så i stedet for at gøre noget som "EngineDebugSingleObj-> SomeFunction ()", laver vi "EngineDebugSingleton:: Some Function ()". Dette gør det muligt for en singleton at få adgang stort set overalt i koden, forudsat at du har #inkluderet header -filen i den specifikke projektfil, du arbejder med. Med dette kan du også oprette singletonen gennem alle dens offentlige funktioner.

Til vores formål i dette trin oprettede vi to offentlige statiske tomrumsfunktioner, "add ()" og "subtract ()". I den private sektion har vi yderligere to funktioner, "PrivAdd ()" og "PrivSubtract ()". Vi tilføjede også en int -variabel kaldet “NumberOfThings”. Definitionen for disse funktioner vil gå ind i vores klassers CPP -fil. For let at få funktionen til at komme ind i CPP -filen markerer du funktionen med markøren, som skal have en grøn linje under, og trykker på “Venstre ALT + ENTER”, det giver dig mulighed for at oprette definitionen i klasser 'tilhørende CPP -fil. Se foto 6.1 for at se, hvordan header -filen skal se ud, og efter at du har oprettet alle funktionsdefinitionerne, skal din CPP ligne foto 6.2, bortset fra at dine funktionsdefinitioner ikke har nogen kode i dem.

Du vil nu tilføje den samme kode som i Foto 6.2 i dine funktionsdefinitioner. Som tidligere nævnt vil vores offentlige funktioner gøre brug af funktionen Instance (), som returnerer det, ptrInstance peger på. Dette giver os adgang til de private funktioner i vores klasse. Med enhver singletons offentlige funktion skal du kun kalde den forekomstfunktion. Den eneste undtagelse hertil er vores Terminate -funktion.

Bemærk: De nøjagtige offentlige og private funktioner, der vises i dette trin, er ikke nødvendige, du kan have forskellige funktionsnavne og operationer i den private funktion, men for enhver form for offentlig funktion skal du have en privat funktion til at følge med den og den offentlige funktion skal i vores tilfælde altid bruge funktionen Instance ().

Trin 7: Oprettelse af afslutningsfunktionen

Da vi kun kan lokalisere vores singleton fra hukommelsen i vores klasse, skal vi oprette en statisk offentlig funktion. Denne funktion kalder delete på ptrInstance, som kalder klassen destructor, og derefter vil vi gerne sætte ptrInstance tilbage til nullptr, så det kan tildeles igen, hvis dit program ikke slutter. Du vil også gerne afslutte dine Singletons for at rydde op i allokeret hukommelse, som du har tildelt i enhver Singletons private variabler.

Trin 8: Indstilling af PtrInstance til Nullptr

For at fuldføre din singleton vil du gå over til EngineDebugSingleton. CPP -filen og i toppen af CPP -filen i vores eksempel skrive "EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr."

Hvis du gør dette, indstilles ptrInstance i første omgang til nullptr, så når du først går igennem instansfunktionen for første gang, får vores klasse lov til at blive allokeret til hukommelsen. Uden det vil du højst sandsynligt få en fejl, fordi du vil forsøge at få adgang til hukommelse, der ikke er tildelt noget.

Trin 9: Test og konklusion

Vi vil nu teste, at vores singleton for at sikre, at det fungerer, dette vil indebære, at vi kalder de offentlige funktioner som beskrevet i trin 6, og vi anbefaler, at du opretter breakpoints for at gå gennem din kode og se, at singleton fungerer som det bør være. Vores udgangspunkt vil være i vores projekts main.cpp, og vores main.cpp ligner nu billedet herunder.

Tillykke! Du har netop gennemført din første implementering af Singleton Design Pattern. Med dette designmønster kan du nu strømline din kode på forskellige måder. For eksempel kan du nu lave managersystemer, der fungerer på tværs af dit programs løbetid, som kan tilgås via statiske funktioner hvor som helst, hvor du har inkluderet klassen.

Din sidste header -fil skal ligne billedet 7.1. Din singletons associerede CPP -fil skal ligne foto 6.2 med tilføjelse af, øverst i filen, af koden vist i trin 8. Denne instruktion gav dig en enkel struktur af Singleton Design Pattern.

Råd om fejlfinding:

Får du hukommelsesrelaterede fejl?

Sørg for at henvise til trin 7 og trin 8 for at sikre, at du indstiller ptrInstance til nullptr.

Uendelig sløjfe opstår?

Sørg for de offentlige funktioner i deres definitioner, at du kalder den private funktion, ikke den samme offentlige funktion.

Objekter tildelt inden for singleten, der forårsager hukommelseslækager?

Sørg for at ringe til din singletons afslutningsfunktion, når det er relevant inden for din programkode, og i destruktoren af din singleton skal du sørge for at allokere alle objekter, der blev allokeret til hukommelse inden for omfanget af singleton-koden.