Før vi forstår konseptet med Bad_weak_PTR -klassen, må vi vite hva delte pekere og svake pekere er. Delte pekere er de der vi kan kopiere pekeren i forskjellige variabler. Vi kan si at delte pekere har delt eierskap der den svake pekeren i seg selv ikke har noe eierskap: det tar eierskapet fra de delte pekerne som referanse. Bad_weak_ptr er den innebygde klassen som er gitt av standard C++. Det er den som brukes til å kaste objektet som et unntak gjennom konstruktøren av de delte pekerne, og det tar den svake pekeren som et argument. Selve den svake pekeren refererer til et slettet objekt.

Syntaks:

Nedenfor vist er syntaks for å opprette unntaket BAD_WEAK_PTR -klasse.

klasse Bad_weak_ptr: public Std :: Unntak
bad_weak_ptr ();
const char *hva () kast ();
;

Denne klassen definerer et unntak som vi kan kaste ved å bruke den delte pekerne konstruktør som holder argumentet for typen den svake pekeren. I syntaks er ovennevnte unntak feilen vi vil kaste mens den dårlige svake pekeren oppstår. Inne i klassefunksjonen erklærte vi to funksjoner av konstant karakterdatatype som er “hva ()” og “kast ()” -metoden. "What ()" -funksjonen brukes til å returnere det avsluttet tegnet som identifiserer det brukte unntaket og "kastet ()" brukes til å kaste unntaket når kompilatoren oppdager problemet. Returverdien for den dårlige svake pekeren er den null-terminerte strengen med forklaringen.

Eksempel # 01:

La oss nå utføre et eksempel på bad_weak_ptr for å sjekke hvordan det fungerer. Det første trinnet for å bli utført i dette er å inkludere overskriftsfilene “IOSTREM” og “Memory”. "Iostream" gir muligheten til å utføre input-output-operasjoner; Mens "minnet" lar oss utføre forskjellige operasjoner relatert til minnetildeling osv.

Nå, i hovedfunksjonen, erklærte vi en delt peker av heltallstype med navnet “PTR”. Til den pekeren passerte vi heltallverdien “42” og ved å bruke det nye nøkkelordet, tildelte vi det til minneskuffen. Og ved å bruke den svake pekeren erklærte vi en BAD_WEAK_PTR kalt “BAD_WEAK_POINTER” som vi refererte til den delte pekeren “PTR”. Nå, ved å bruke nøkkelordet for tilbakestilling (), vil vi tilbakestille bitene på den medfølgende indeksen til "PTR" til NULL eller "0". Deretter vil vi ringe Try uttalelsen som brukes til å utføre noe definert av brukeren. Inne i dette har vi erklært en annen delt peker som heter “P2” som vil holde den dårlige svake pekeren “bad_weak_pointer”. Nå kaller vi fangst () -erklæringen som lar oss definere utførelsesblokken når feilen oppstår. Til fangst () uttalelsen passerte vi BAD_WEAK_PTR og "feilen" som en parameter. "Feilen" brukes til å holde feilen som vil oppstå i dette programmet. Inne.

#inkludere
#inkludere
int main ()

STD :: Shared_PTR PTR (New Int (42));
std :: svake_ptr bad_weak_pointer (PTR);
PTR.nullstille();
prøv
std :: shared_ptr p2 (bad_weak_pointer);
fangst (const std :: bad_weak_ptr & err)
std :: cout << err.what() << '\n';

La oss nå sjekke utdataene våre der det er vist en feil som skjedde på grunn av den dårlige svake pekeren.

Eksempel # 02:

I dette eksemplet vil vi prøve å utføre et annet BAD_WEAK_PTR -program der vi vil lage et objekt av delt pekertype og ringe konstruktøren og destruktøren. La oss ha et detaljert syn på koden som vi skal utføre. Etter å ha inkludert de samme overskriftsfilene som vi har inkludert i eksemplet ovenfor. Vi vil lage et objekt “BD_PTR” ved hjelp av struktur. Og kalt enabled_shared_from_his for BD_PTR -objektet som tillater objektet BD_PTR som administreres av den delte pekeren som heter “BD_PTR”.

Inne i dette objektet vil vi ringe konstruktøren for “BD_PTR” og Destructor. Inne i begge funksjonene består vi også uttalelsen som vil vises på deres vellykkede utførelse. Og opprettet også en funksjon for dette objektet “BD-PTR” kalt “getBdptr” som vil returnere Shared_PTR som vil dele eierskapet til “dette”. Metoden "Shared_From_this ()" brukes for å tillate objektet som den delte pekeren administrerer, den tillater opprettelse av en forekomst for objektet til den delte pekeren. Nå, og går videre til hovedfunksjonen vår der vi kalte Try uttalelsen der vi erklærte en variabel med navnet "F" av objektet "BD_PTR" som vi tildelte en minneskikk ved hjelp av et "nytt" nøkkelord.

Vi opprettet også en delt peker av typen “BD_PTR” som heter “SP” som vi har tildelt en GetBdptr () -metode ved å peke via variabel “F” av Type -objektet. Ved hjelp av “->” -operatøren fikk vi tilgang til elementet i strukturen for variabelen “F”. Til fangstmetoden passerte vi en konstant type BAD_WEAK_PTR kalt “BadweakPtr”, noe som betyr at hvis unntaket BAD_WEAK_PTR oppstår, vil den vise den indre koden som vi har skrevet i de krøllete seler der den vil vise navnet på unntaket som oppstår Og på slutten avslutter vi koden med -1.

#inkludere
#inkludere
struct bd_ptr: public std :: enable_shared_from_this
bd_ptr () std :: cout << "bad pointer constructor\n";
~ bd_ptr () std :: cout << "bad pointer destructor\n";
std :: shared_ptr getBdptr () return shared_from_this ();
;
int main ()

prøve

BD_PTR *F = NY BD_PTR;
std :: shared_ptr sp = f-> getBdptr ();

Catch (const std :: bad_weak_ptr & badweakptr)

std :: cout << badweakptr.what();
Avslutt (-1);

retur 0;

I utdraget nedenfor har vi utført konstruktørens skapelsesmelding, noe som betyr at konstruktøren vår er opprettet med hell. Men destruktøren kjøres ikke fordi vi har kastet et unntak for den dårlige svake pekeren. Så den viste den indre koden som vi har skrevet i fangstfunksjonen som viste typen feil som skjedde.

Konklusjon

I denne guiden har vi studert unntaket som er bad_weak_ptr som brukes til å kaste unntaket og returnerer meldingstypen på feilen som oppstår på utførelsestidspunktet. Vi utførte forskjellige eksempler for å forklare konseptet med dette unntaket og hvordan det brukes i koden. Vi prøvde vårt beste for å forklare arbeidet med Bad_weak_PTR.