Prima di capire il concetto della classe BAD_WEAK_PTR, dobbiamo sapere quali sono i puntatori condivisi e i puntatori deboli. I puntatori condivisi sono quelli in cui possiamo copiare il puntatore in diverse variabili. Possiamo dire che i puntatori condivisi hanno una proprietà condivisa in cui il puntatore debole stesso non ha alcuna proprietà: prende la proprietà dai puntatori condivisi come riferimento. BAD_WEAK_PTR è la classe integrata fornita dallo standard C++. È quello che viene usato per lanciare l'oggetto come eccezione attraverso il costruttore dei puntatori condivisi e prende il punta debolo come argomento. Il puntatore debole stesso si riferisce a un oggetto cancellato.

Sintassi:

Di seguito è riportato la sintassi per la creazione dell'eccezione della classe BAD_WEAK_PTR.

Classe Bad_weak_ptr: public std :: Eccezione
BAD_WEAK_PTR ();
const char *What () Throw ();
;

Questa classe definisce un'eccezione che possiamo lanciare usando il costruttore di puntatori condivisi che tiene l'argomento del tipo di punta debole. Nella sintassi, l'eccezione sopra è l'errore che lanceremo mentre si verifica il cattivo puntatore debole. All'interno della funzione di classe, abbiamo dichiarato due funzioni di tipo di dati di carattere costanti che sono il metodo "What ()" e "Throw ()". La funzione "What ()" viene utilizzata per restituire il carattere terminato che identifica l'eccezione usata e il "lancio ()" viene utilizzato per lanciare l'eccezione ogni volta che il compilatore rileva il problema. Il valore di ritorno per il cattivo puntatore debole è la stringa con terminazione nulla con la spiegazione.

Esempio # 01:

Eseguiamo ora un esempio di BAD_WEAK_PTR per controllare come funziona. Il primo passo per essere eseguito in questo è includere i file di intestazione "iostrem" e la "memoria". "Iostream" fornisce la possibilità di eseguire operazioni di input-output; mentre la "memoria" ci consente di eseguire varie operazioni relative all'allocazione della memoria, ecc.

Ora, nella funzione principale, abbiamo dichiarato un puntatore condiviso di tipo intero con il nome "PTR". A quel puntatore, abbiamo superato il valore intero "42" e usando la nuova parola chiave, l'abbiamo assegnato al mucchio di memoria. E poi, usando il puntatore debole, abbiamo dichiarato un BAD_WEAK_PTR chiamato "BAD_WEAK_POINTER" a cui abbiamo fatto riferimento al puntatore condiviso "PTR". Ora, utilizzando la parola chiave reset (), ripristineremo i bit sull'indice fornito di "PTR" su null o "0". Successivamente, chiameremo l'istruzione Try che viene utilizzata per eseguire qualcosa definito dall'utente. All'interno di questo, abbiamo dichiarato un altro puntatore condiviso chiamato "P2" che manterrà il cattivo puntatore debole "BAD_WEAK_POINTER". Ora, chiamiamo l'istruzione Catch () che ci consentirà di definire il blocco di esecuzione ogni volta che si verifica l'errore. All'istruzione Catch (), abbiamo superato il BAD_WEAK_PTR e il "err" come parametro. Il "err" viene utilizzato per contenere l'errore che si verificherà in questo programma. All'interno della variabile "ERR" delle parentesi ricci visualizzerà il tipo di errore che si verifica in questo codice usando il metodo What (), che viene utilizzato per ottenere l'istruzione che identifica l'errore.

#includere
#includere
int main ()

std :: shared_ptr ptr (new int (42));
std :: debole_ptr Bad_weak_pointer (PTR);
PTR.Ripristina();
Tentativo
std :: shared_ptr P2 (BAD_WEAK_POINTER);
catch (const std :: bad_weak_ptr & err)
std :: cout << err.what() << '\n';

Ora, diamo un'occhiata al nostro output in cui è stato visualizzato un errore che si è verificato a causa del cattivo puntatore debole.

Esempio # 02:

In questo esempio, proveremo a eseguire un altro programma BAD_WEAK_PTR in cui creeremo un oggetto di tipo puntatore condiviso e chiameremo il costruttore e il distruttore. Abbiamo una visione dettagliata del codice che stiamo per eseguire. Dopo aver incluso gli stessi file di intestazione che abbiamo incluso nell'esempio sopra. Creeremo un oggetto "bd_ptr" usando la struttura. E chiamato abilitable_shared_from_this per l'oggetto bd_ptr che consente l'oggetto bd_ptr gestito dal puntatore condiviso chiamato "bd_ptr".

All'interno di questo oggetto, chiameremo il costruttore per "BD_PTR" e il distruttore. Inoltre, all'interno di queste funzioni, passiamo l'affermazione che verrà visualizzata sulla loro esecuzione di successo. E ha anche creato una funzione per questo oggetto "BD-PTR" chiamato "GetBDPTR" che restituirà il Shared_PTR che condividerà la proprietà di "questo". Viene utilizzato il metodo "shared_from_this ()" per consentire all'oggetto che il puntatore condiviso sta gestendo, consente la creazione di un'istanza per l'oggetto del puntatore condiviso. Ora, passando nella nostra funzione principale in cui abbiamo chiamato l'istruzione Try in cui abbiamo dichiarato una variabile denominata "F" dell'oggetto "bd_ptr" a cui abbiamo assegnato un mucchio di memoria usando una "nuova" parola chiave.

Abbiamo anche creato un altro puntatore condiviso del tipo "bd_ptr" chiamato "sp" a cui abbiamo assegnato un metodo getbdptr () puntando tramite la variabile "f" dell'oggetto tipo. Usando l'operatore "->", abbiamo accettato l'elemento della struttura per la variabile "F". Al metodo Catch, abbiamo superato un tipo costante BAD_WEACK_PTR chiamato "Badweakptr", il che significa che se si verifica l'eccezione Bad_weak_ptr, visualizzerà il codice interno che abbiamo scritto all'interno delle parentesi graffe in cui visualizzerà il nome dell'eccezione che si verifica E alla fine, usciamo dal codice con -1.

#includere
#includere
struct bd_ptr: public std :: abilita_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 ()

Tentativo

bd_ptr *f = new bd_ptr;
std :: shared_ptr sp = f-> getBdptr ();

catch (const std :: bad_weak_ptr e badweakptr)

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

restituzione 0;

Nel frammento di seguito, abbiamo eseguito correttamente il messaggio di creazione del costruttore che significa che il nostro costruttore viene creato correttamente. Ma il Destructor non esegue perché abbiamo lanciato un'eccezione per il cattivo puntatore debole. Quindi, ha visualizzato il codice interno che abbiamo scritto all'interno della funzione di cattura che ha visualizzato il tipo di errore che si è verificato.

Conclusione

In questa guida, abbiamo studiato l'eccezione che è BAD_WEAK_PTR che viene utilizzata per lanciare l'eccezione e restituire il tipo di messaggio dell'errore che si verifica al momento dell'esecuzione. Abbiamo eseguito diversi esempi per spiegare il concetto di questa eccezione e come viene utilizzata nel codice. Abbiamo fatto del nostro meglio per spiegare il funzionamento di BAD_WEAK_PTR.