C ++ STD Weak_PTR

Forutsetningen for å studere den svake pekeren er at vi burde vite om de unike pekerne og de delte pekerne. En unik peker har unikt eierskap. Det har de administrerte objektene og tillater ikke noen å håndtere de objektene. La oss anta at vi har et objekt som heter “P” som administreres av en unik peker. Da kan vi ikke kopiere denne pekeren. I det andre tilfellet, for den delte pekeren, har vi også “P”, men vi bruker en delt peker. Denne gangen kan du kopiere denne delte pekeren i flere forskjellige variabler, og vi vil bruke en referansetelling for å telle hvor mange smarte pekere som bruker eller peker på akkurat dette administrerte objektet.

Nå kan vi si at den unike pekeren er for unikt eierskap. Den delte pekeren er for delt eierskap. Og den svake pekeren er for ikke-eierskap. En svak peker er også en smart peker; det vil ikke delta i eierskapet i det hele tatt. Det er en referanse til et objekt som administreres av en delt peker. Nå, en ting som kan sitte fast i tankene våre, er at hvis den svake pekeren ikke har noe eierskap som en unik eller delt peker, hvordan vil denne svake pekeren håndteres? Pekeren har ikke noe med det, det tar det administrerte objektet fra de delte pekerne. De er vant til å bryte de delte sirkulære avhengighetene.

Syntaks:

Syntaksen for å bruke en svak peker i programmet er som følger:

std :: svake_ptr P (ny int);

I den gitte syntaks er typen datatypen som den svake pekeren kontrollerer.

Eksempel 1:

For å forstå den svake pekeren på en bedre måte, la oss først gi et eksempel, så det vil være lettere for oss å forstå hvordan det fungerer. I dette eksemplet lager vi en svak peker ved hjelp av de delte pekerne og lager tellingen antall referanser ved hjelp av den svake pekeren. Som vi tidligere diskuterte, har ikke den svake pekeren i seg selv eierskap; Det krever eierskap til andre tips for å bryte en sirkulær avhengighet av objekter. Nå, å bevege oss mot koden vår der vi først inkluderer to overskriftsfiler - den første overskriftsfilen er "Memory" og den andre overskrifterfilen er "iostream". "Iostream" brukes til å la koderen utføre I/O -operasjonene mens "minnet" er biblioteket som brukes til å administrere det dynamiske minnet.

Deretter beveger vi oss inn i hovedfunksjonen der vi definerer en delt peker av heltallstype og navngir pekeren “SHR_PTR_A”. Ved hjelp av den "nye" operatøren tildeler vi minnet ved haugen for int "12". Nå erklærer vi en svak peker for heltallstype og navngir den som "wk_ptr" som vi passerer den delte pekeren. Dette betyr at det holder referansen til heltallet “12”. Etter å ha erklært det med hell, skriver vi ut antallet tellinger som den svake pekeren kalles ved hjelp av “use_count ()” som brukes til å returnere antall delte pekerforekomster som administrerer det nåværende objektet. I dette eksemplet utfører vi dette trinnet 3 ganger ved å lage de tre delte objektene. På slutten av koden returnerer vi nullverdiene.

#inkludere
#inkludere
int main ()

std :: shared_ptr SHR_PTR_A (ny int (12));
std :: svake_ptr WK_PTR (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr SHR_PTR_B (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr SHR_PTR_C (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
return (0);

La oss nå sjekke utdataene fra koden som vises i følgende utdrag der vi skriver ut antall referanser som er opprettet. Etter opprettelsen av hver referanse, skriver vi ut tellingen for det. For den første utgangen var den en, for den andre utgangen var den 2, og for den siste utgangen var den 3. Dette betyr at de totalt tre referansene opprettes ved hjelp av den svake pekeren.

Eksempel 2:

Vi utfører et annet eksempel der vi lager to klasser og ødelegger dem ved hjelp av den svake pekeren. Hver gang vi får tilgang til et hvilket som helst objekt eller sletter det når som helst med en smart peker, brukes en svak peker til å spore det. Den konverteres til en delt peker som midlertidig eierskap. Hvis vi ønsker å ødelegge den opprinnelige delte pekeren, blir levetiden for objektet utvidet til vi ødelegger den midlertidige delte pekeren.

La oss nå gå videre til koden der vi først inkluderer toppfilene. Før vi dykker ned i hovedfunksjonen, erklærer vi to klasser - den første er "Class_a" og den andre er "Class_B". Inne i "class_a" definerer vi først en svak peker som heter "BPTR" ved å passere "class_b" som en parameter. Deretter kaller vi en konstruktør og en destruktør for "class_a". Vi gjentar de samme trinnene for "class_b" der vi definerer en svak peker og passerer en "class_a" som en parameter. Konstruktøren viser en opprettelse av klassemeldingen. Når ødeleggelsesfunksjonen kalles, viser den klassen ødelagt melding.

Etter det hopper vi inn i hovedfunksjonen der vi erklærer de delte pekerne som navngir “A” og “B” som vi tildeler en "make_shared" -funksjon der vi passerer begge klassene som en parameter. "Make_shared" -funksjonen brukes til å tildele og lage alle typer objekter ved å passere datatypen som et argument. Den returnerer gjenstanden for den delte pekeren som er eieren av objektet og lagrer den. Til slutt, ved å bruke “A” og “B” delte pekere, indekserer vi dem for å få tilgang til minneindeksen bak stedene som er angitt med “BPTR” og “APTR”. Dette betyr at vi tildeler de delte pekere -objektene til den svake pekeren.

#inkludere
#inkludere
klasse klasse_b;
Klasseklasse_a

offentlig:
std :: svake_ptrBPTR;
class_a ()
std :: cout << "class_a created sucessfully" << std::endl;

~ class_a ()
std :: cout << "class_a destroyed sucessfully" << std::endl;

;
Klasseklasse_B

offentlig:
std :: svake_ptrAPTR;
class_b ()
std :: cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: cout << "class_b destroyed sucessfully" B-> APTR = A;

I det følgende utdraget vises utdataene fra koden vår der vi kan sjekke at begge class_and class_b er opprettet og ødelagt vellykket.

Konklusjon

I denne artikkelen studerte vi bruken av svake pekere, hvordan de fungerer og formålet med å bruke de svake pekerne ved å bruke flere eksempler, inkludert kode og utgang. Svake tips spiller en viktig rolle i C++. I koordinering med de delte pekerne hjelper svake pekere mens de erklærer eller initialiserer en optimalisert syklus for å få elementene. De hjelper også til å anskaffe ressurser.