Slik gjør du Singleton -designmønsteret i C ++: 9 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

Introduksjon:

Hensikten med denne instruksjonsguiden er å lære brukeren hvordan man implementerer singleton -designmønsteret i sitt C ++ - program. Ved å gjøre dette vil dette instruksjonssettet også forklare leseren hvorfor elementer i en singleton er slik de er og hvordan koden behandles. Å vite dette, vil i fremtiden hjelpe med feilsøking av fremtidige singletons. Hva er singleton -designmønsteret? Singleton -designmønsteret er et designmønster der koderen oppretter en klasse som bare kan instantieres én gang, klassenes offentlige funksjoner kan i utgangspunktet nås hvor som helst, forutsatt at du har #inkludert header -filen i andre prosjektrelaterte filer.

Singleton-designmønsteret er et must-kjend designmønster for enhver objektorientert programmerer, programvare og spillprogrammerere. Singleton -designmønsteret er også et av de enkleste kodende designmønstrene som finnes. Å lære det kan hjelpe deg med å lære andre, vanskeligere designmønstre i fremtiden. Det kan også hjelpe deg med å effektivisere programmets kode på måter du ikke trodde var mulig.

Selv om vanskeligheten med singleton -designmønsteret er lett sammenlignet med andre designmønstre, har dette instruksjonssettet en middels vanskelighet. Dette betyr at for å gjøre disse instruksjonene, anbefaler vi at du kjenner grunnleggende og forhåndssyntakskrav til C ++. Du bør også kjenne riktig C ++ kodingsetikett (dvs. Hold klassevariabler private, en klasse per toppfil osv.). Du bør også vite hvordan du frigjør minne og hvordan konstruktører og destruktorer fungerer i C ++.

Denne instruksjonsguiden vil i gjennomsnitt ta rundt 10-15 minutter.

Materialkrav:

-En datamaskin (kan være PC eller Mac) som kan kjøre Visual Studios (hvilken som helst versjon)

-Et enkelt program, laget i Visual Studios, som du kan teste singelen din med

Merk: Singleton -designmønsteret kan utføres på alle andre C ++ - støttende IDE- eller kodingsgrensesnitt, men for dette instruksjonssettet bruker vi Visual Studios Enterprise Edition.

Trinn 1: Lag klassen din, med toppfil og CPP -fil

For å opprette disse to filene og klassen på en gang, åpner du prosjektet / programmet i Visual Studios, går over til løsningsutforskeren, høyreklikker, og en boks skal dukke opp nær musemarkøren, finn alternativet "Legg til", hold markøren over den, og en annen boks skal vises til høyre. I denne boksen vil du finne alternativet "Nytt element..", klikk på det og et vindu som ligner bildet 1.1 -bildet nedenfor, skal vises. I dette vinduet vil du velge "C ++ Class" og deretter trykke "Legg til". Dette åpner et nytt vindu som ligner bildet 1.2. I dette vinduet skriver du inn navnet på klassen din i "Klassenavn" -feltet, og Visual Studios vil automatisk navngi den faktiske filen etter klassenavnet. Av hensyn til denne instruksjonen skal vi gi klassen vår navnet "EngineDebugSingleton", men det kan være et hvilket som helst bokstavbasert navn. Du kan nå trykke "OK" og gå videre til trinn 2.

Merk: Løsningsutforskeren og hvor filene er lagret på datamaskinen din er atskilt. Å flytte eller lage noe i løsningsutforskeren vil ikke flytte eller organisere filene i OS -filutforskeren. En trygg måte å organisere filene dine på filutforskersiden vil være å fjerne, men ikke slette de spesifikke filene fra løsningsutforskeren, flytte de samme filene i filutforskeren til ønsket sted og deretter gå tilbake til løsningsutforsker, høyreklikk, finn alternativet "Legg til", finn deretter "Eksisterende element" og finn filene du flyttet. Sørg for å flytte både topp- og cpp -filen.

Trinn 2: Sett konstruktøren til privat

Med den nyopprettede CPP -filen og toppteksten, hvis den ikke åpnet seg automatisk da du opprettet den, går du til løsningsutforskeren og klikker og åpner "EngineDebugSingleton.h". Du vil da bli møtt med en "EngineDebugSingleton ()", klassens standardkonstruktør og "~ EngineDebugSingleton ()" klassedestruktoren. For dette trinnet vil vi sette konstruktøren til det private, dette betyr at denne funksjonen bare er tilgjengelig for klassen og ingenting annet. Med dette vil du ikke kunne lage en variabel eller allokere klassen til minne utenfor klassen, bare i klassenes overskriftsfil og klassens andre funksjoner. Å ha konstruktøren privat er nøkkelen til designmønsteret og hvordan singletoner fungerer. Vi vil i fremtidige trinn oppdage hvordan en singleton blir instantiert og tilgjengelig.

Klassen skal nå se slik ut etter å ha flyttet konstruktøren til privat (Se på tilhørende bilde)

Trinn 3: Sett Destructor til Privat

Som vi gjorde med konstruktøren i

trinn 2, for dette trinnet, vil vi nå sette destruktoren til privat. Som med konstruktøren vil ingenting, bortsett fra selve klassen, kunne slette eventuelle variabler i klassen fra minnet.

Klassen skal nå se slik ut etter å ha fullført dette trinnet. (Se tilknyttet bilde)

Trinn 4: Opprette en statisk pekervariabel i Singleton

I dette trinnet vil vi lage en

statisk pekervariabel av typen "EngineDebugSingleton*". Dette vil være variabelen som vil bli brukt til å tildele singletonen vår til minnet, og vil peke på den for hele tiden singelen vår er tildelt minne.

Slik skal header -filen vår se ut etter å ha opprettet denne variabelen

Trinn 5: Opprette en forekomstfunksjon

Vi vil nå lage en forekomst

funksjon. Funksjonen må være en statisk funksjon og vil returnere en referanse til klassen vår ("EngineDebugSingleton &"). Vi kalte vår funksjon Instance (). I selve funksjonen vil vi først teste om ptrInstance == nullptr (kan forkortes til! PtrInstance), hvis det er nullptr, betyr dette at singleton ikke har blitt tildelt og i omfanget av if -setningen, vil vi vil tildele ved å gjøre ptrInstance = new EngineDebugSingleton (). Det er her du faktisk tildeler singleton til minne. Etter å ha forlatt omfanget av if -setningen, vil vi deretter returnere det ptrInstance peker på, som er angitt med syntaksen "*ptrInstance". Vi kommer til å bruke denne funksjonen tungt når vi skal gjøre våre statiske offentlige funksjoner, så vi kan sjekke om singletonen er opprettet og allokert til minne. I hovedsak gjør denne funksjonen det slik at du bare kan ha en tildeling av klassen og ikke mer.

Slik skal klassen vår se ut nå etter å ha opprettet Instance () -funksjonen. Som du kan se, har alt vi har gjort i den private delen av klassen, dette kommer til å endre seg litt i de neste trinnene.

Trinn 6: Opprette statiske offentlige funksjoner

Etter at du har laget funksjonen fra

trinn 5, kan du begynne å lage statiske offentlige funksjoner. Hver offentlig funksjon bør ha en privat funksjon som kan brukes sammen med den. Navnet på denne funksjonen kan ikke være det samme. Hvorfor gjøre funksjonen statisk? Vi gjør de offentlige funksjonene statiske slik at de kan nås uten et faktisk objekt. Så i stedet for å gjøre noe som "EngineDebugSingleObj-> SomeFunction ()", gjør vi "EngineDebugSingleton:: Some Function ()". Dette gjør det mulig for en singleton å få tilgang til i hovedsak hvor som helst i koden, forutsatt at du har #inkludert hovedfilen i den spesifikke prosjektfilen du jobber med. Med dette kan du også opprette singleton gjennom noen av de offentlige funksjonene.

For våre formål i dette trinnet opprettet vi to offentlige statiske tomfunksjoner, "add ()" og "subtract ()". I den private delen har vi ytterligere to funksjoner, "PrivAdd ()" og "PrivSubtract ()". Vi la også til en int -variabel kalt "NumberOfThings". Definisjonen for disse funksjonene vil gå inn i klassenes CPP -fil. For enkelt å få funksjonen til å komme inn i CPP -filen, markerer du funksjonen med markøren, som skal ha en grønn linje under, og trykker på “Venstre ALT + ENTER”, det gir deg muligheten til å lage definisjonen i klasser 'tilhørende CPP -fil. Se Bilde 6.1 for å se hvordan toppfilen skal se ut, og etter at du har opprettet alle funksjonsdefinisjonene, bør CPP se ut som Foto 6.2, bortsett fra at funksjonsdefinisjonene ikke har noen kode i dem.

Du vil nå legge til den samme koden som i Foto 6.2 i funksjonsdefinisjonene. Som nevnt tidligere vil våre offentlige funksjoner bruke Instance () -funksjonen, som vil returnere det ptrInstance peker på. Dette gir oss tilgang til de private funksjonene i klassen vår. Med en singletons offentlige funksjon bør du bare kalle den forekomstfunksjonen. Det eneste unntaket fra dette er vår Terminate -funksjon.

Merk: De eksakte offentlige og private funksjonene som vises i dette trinnet er ikke nødvendige, du kan ha forskjellige funksjonsnavn og operasjoner i den private funksjonen, men for alle typer offentlige funksjoner bør du ha en privat funksjon som kan følges med den og den offentlige funksjonen bør alltid bruke, i vårt tilfelle, funksjonen ().

Trinn 7: Opprette avslutningsfunksjonen

Siden vi bare kan dele vår singleton fra minnet i klassen vår, må vi lage en statisk offentlig funksjon. Denne funksjonen vil kalle delete på ptrInstance, som kaller klassen destructor, og så vil vi sette ptrInstance tilbake til nullptr, slik at det kan bli tildelt igjen hvis programmet ikke slutter. Du vil også avslutte Singletons for å rydde opp i tildelt minne som du tildelte i Singletons private variabler.

Trinn 8: Angi PtrInstance til Nullptr

For å fullføre singletonen din, vil du gå over til EngineDebugSingleton. CPP -filen og i toppen av CPP -filen skriver du "EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr."

Hvis du gjør dette, vil ptrInstance i utgangspunktet settes til nullptr, så når du først går gjennom forekomstfunksjonen for første gang, får klassen vår allokering til minne. Uten det vil du mest sannsynlig få en feil fordi du vil prøve å få tilgang til minne som ikke har noe tildelt det.

Trinn 9: Test og konklusjon

Vi vil nå teste at singelen vår for å sikre at den fungerer, dette vil innebære at vi kaller de offentlige funksjonene som beskrevet i trinn 6, og vi anbefaler at du setter opp brytpunkter for å gå gjennom koden din og se at singleton fungerer som det bør være. Vårt utgangspunkt vil være i prosjektets main.cpp og main.cpp ser nå ut som bildet nedenfor.

Gratulerer! Du har nettopp fullført din første implementering av Singleton Design Pattern. Med dette designmønsteret kan du nå effektivisere koden på en rekke måter. For eksempel kan du nå lage managersystemer som fungerer på tvers av programmets kjøretid, som kan nås via statiske funksjoner hvor som helst der du har inkludert klassen.

Den siste overskriftsfilen skal se ut som bildet 7.1. Singletons assosierte CPP -fil skal se ut som Foto 6.2 med tillegg av, øverst i filen, av koden vist i trinn 8. Denne instruksjonen ga deg en enkel struktur av Singleton Design Pattern.

Råd om feilsøking:

Får du minne -relaterte feil?

Sørg for at du refererer til trinn 7 og trinn 8 for å være sikker på at du setter ptrInstance til nullptr.

Uendelig sløyfe oppstår?

Sørg for at de offentlige funksjonene, i definisjonene deres, kaller du den private funksjonen, ikke den samme offentlige funksjonen.

Objekter tildelt i singleton forårsaker minnelekkasjer?

Sørg for å ringe singletons avslutningsfunksjon når det er hensiktsmessig innenfor programkoden din, og i destruktoren til singletonen din, sørg for at du allokerer alle objekter som ble tildelt minne innenfor omfanget av singleton-koden.