C ++ std depeater_ptr

Il prerequisito per studiare il puntatore debole è che dovremmo conoscere i puntatori unici e i puntatori condivisi. Un puntatore unico ha una proprietà unica. Contiene gli oggetti gestiti e non consente a nessuno di gestire quegli oggetti. Supponiamo che abbiamo un oggetto chiamato "P" che è gestito da un puntatore unico. Quindi, non possiamo copiare questo puntatore. Nell'altro caso, per il puntatore condiviso, abbiamo anche "P" ma stiamo usando un puntatore condiviso. Questa volta, puoi copiare questo puntatore condiviso in diverse variabili e useremo un conteggio di riferimento per contare quanti puntatori intelligenti stanno usando o indicano questo particolare oggetto gestito.

Ora possiamo dire che il puntatore unico è per la proprietà unica. Il puntatore condiviso è per la proprietà condivisa. E il puntatore debole è per non proprietà. Un puntatore debole è anche un puntatore intelligente; non parteciperà affatto alla proprietà. È un riferimento a un oggetto che è gestito da un puntatore condiviso. Ora, una cosa che può essere bloccata nella nostra mente è che se il puntatore debole non ha alcuna proprietà come un puntatore unico o condiviso, come verrà gestito questo puntatore debole? Il puntatore non ha nulla con esso, prende l'oggetto gestito dai puntatori condivisi. Sono usati per rompere la dipendenza circolare di quelli condivisi.

Sintassi:

La sintassi per l'applicazione di un puntatore debole nel programma è la seguente:

std :: debole_ptr p (nuovo int);

Nella sintassi data, il tipo è il tipo di dati che il puntatore debole controlla.

Esempio 1:

Per capire il puntatore debole in un modo migliore, facciamo prima un esempio in modo che sia più facile per noi capire come funziona. In questo esempio, creiamo un puntatore debole usando i puntatori condivisi e creiamo il conteggio del numero di riferimenti usando il puntatore debole. Come abbiamo discusso in precedenza, il puntatore debole stesso non ha la proprietà; Ci vuole la proprietà di altri puntatori per rompere una dipendenza circolare degli oggetti. Ora, spostandosi verso il nostro codice in cui includiamo per la prima volta due file di intestazione: il primo file di intestazione è la "memoria" e il secondo file di intestazione è "iostream". "Iostream" viene utilizzato per consentire al coder di eseguire le operazioni I/O mentre la "memoria" è la libreria utilizzata per gestire la memoria dinamica.

Successivamente, ci spostiamo nella funzione principale in cui definiamo un puntatore condiviso del tipo intero e nominiamo il puntatore "shr_ptr_a". Usando l'operatore "nuovo", allochiamo la memoria sul heap per int "12". Ora, dichiariamo un puntatore debole del tipo intero e lo chiamiamo "wk_ptr" a cui passiamo il puntatore condiviso. Ciò significa che contiene il riferimento dell'intero "12". Dopo averlo dichiarato correttamente, stampiamo il numero di conteggi che il puntatore debole viene chiamato usando "use_count ()" che viene utilizzato per restituire il numero di istanze di punta condivisa che gestisce l'oggetto corrente. In questo esempio, eseguiamo questo passaggio 3 volte creando i tre oggetti condivisi. Alla fine del codice, restituiamo i valori null.

#includere
#includere
int main ()

std :: shared_ptr shr_ptr_a (new int (12));
std :: debole_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;
restituzione (0);

Ora, controlliamo l'output del codice visualizzato nel seguente frammento in cui stampiamo il numero di riferimenti creati. Dopo la creazione di ciascun riferimento, stampiamo il conteggio per quello. Per il primo output era uno, per la seconda uscita era 2, e per l'ultima uscita era 3. Ciò significa che i tre riferimenti totali vengono creati usando il puntatore debole.

Esempio 2:

Eseguiamo un altro esempio in cui creiamo due classi e le distruggiamo usando il puntatore debole. Ogni volta che accediamo a qualsiasi oggetto o lo eliminiamo in qualsiasi momento da qualsiasi puntatore intelligente, viene utilizzato un puntatore debole per seguirlo. Viene convertito in un puntatore condiviso come proprietà temporanea. Se vogliamo distruggere il puntatore condiviso originale, la durata dell'oggetto viene estesa fino a quando non distruggiamo il puntatore condiviso temporaneo.

Ora, procediamo al codice in cui includiamo per la prima volta i file di intestazione. Prima di immergerci nella funzione principale, dichiariamo due classi: la prima è il "class_a" e il secondo è il "class_b". All'interno del "class_a", definiamo per la prima volta un puntatore debole chiamato "BPTR" passando "class_b" come parametro. Quindi, chiamiamo un costruttore e un distruttore per "class_a". Ripetiamo gli stessi passaggi per il "class_b" in cui definiamo un puntatore debole e passiamo un "class_a" come parametro. Il costruttore mostra un messaggio di creazione della classe. Quando viene chiamata la funzione di distruzione, visualizza il messaggio distrutto dalla classe.

Successivamente, saltiamo nella funzione principale in cui dichiariamo i puntatori condivisi che nominano "A" e "B" a cui assegniamo una funzione "Make_Shared" in cui passiamo entrambe le classi come parametro. La funzione "make_shared" viene utilizzata per allocare e creare qualsiasi tipo di oggetto passando il tipo di dati come argomento. Restituisce l'oggetto del puntatore condiviso che è il proprietario dell'oggetto e lo memorizza. Infine, usando i puntatori condivisi "A" e "B", li indicizziamo per accedere all'indice di memoria dietro le posizioni indicate da "BPTR" e "APTR". Ciò significa che assegniamo gli oggetti dei puntatori condivisi al puntatore debole.

#includere
#includere
classe class_b;
Classe Class_A

pubblico:
std :: debole_ptrBPTR;
classe A()
std :: cout << "class_a created sucessfully" << std::endl;

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

;
Classe Class_B

pubblico:
std :: debole_ptrAPTR;
class_b ()
std :: cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: cout << "class_b destroyed sucessfully" b-> aptr = a;

Nel seguente snippet, viene visualizzato l'output del nostro codice in cui possiamo verificare che entrambi Class_and Class_B siano creati e distrutti correttamente.

Conclusione

In questo articolo, abbiamo studiato l'uso di puntatori deboli, come funzionano e lo scopo di usare i puntatori deboli usando più esempi tra cui il codice e l'output. I puntatori deboli svolgono un ruolo vitale in C++. In coordinamento con i puntatori condivisi, i puntatori deboli aiutano mentre dichiarano o inizializza un ciclo ottimizzato per ottenere gli elementi. Aiutano anche nell'acquisizione delle risorse.