C ++ std univoco_ptr
Ogni volta che viene creato il puntatore intelligente, chiamerà automaticamente nuovo e allocherà il mucchio di memoria. Quindi, in base al puntatore intelligente che usi, quella memoria diventerà automaticamente libera. Ora arriviamo al nostro argomento principale, il puntatore unico. Un puntatore unico verrà eliminato quando uscirà dall'ambito. I puntatori unici non possono essere copiati sull'altro puntatore se è dello stesso tipo di dati perché un puntatore unico indica una memoria. Se il puntatore unico è stato copiato, ciò significa in un momento in cui due puntatori indicano lo stesso mucchio di memoria. Quindi, è per questo che non possiamo copiare puntatori unici. I puntatori unici si assicurano di eliminare i loro oggetti con loro.
Sintassi
La sintassi per creare un puntatore unico è la seguente:
std :: univoco_ptrQui, l'oggetto creato dinamicamente viene anche distrutto quando il puntatore unico stesso viene distrutto.
Esempio # 01:
Per comprendere i puntatori unici in modo più approfondito, faremo un esempio. In questo esempio, abbiamo definito una struttura chiamata persona. "Person" ha un costruttore che prende una stringa come parametro e stampa il valore. Ha anche un distruttore che dopo la distruzione stamperà "eliminato" in modo da poter capire che la persona viene distrutta. All'interno del metodo principale, abbiamo dichiarato un puntatore unico e lo ha superato un valore "Jack.".
Ora, questo puntatore prenderà "Jack" e lo passerà alla memoria che indica che è la struttura "persona". Il valore "jack" andrà al costruttore e verrà stampato. Successivamente, il puntatore unico eliminerà automaticamente l'oggetto e "eliminato!"Sarà stampato sullo schermo. Ora, eseguiamo ed eseguiamo il nostro codice per vedere l'output.
#includere#includere
Utilizzo dello spazio dei nomi std;
Persona strutturale
Persona (stringa n): nome (n)
cout<
~ Persona ()
cout<< "Deleted!";
Nome stringa;
;
int
principale ()
auto p = make_unique ("jack");
restituzione 0;
Il nostro codice è stato eseguito correttamente e ci dà l'output previsto. Il puntatore unico ha preso il valore "jack" e lo ha passato al costruttore perché indicava l'oggetto della struttura "persona". Il costruttore ha stampato il valore. Successivamente, "Eliminato" viene stampato. Ora, qui, abbiamo stampato solo il valore. Ma in scenari in tempo reale, possiamo eseguire tutte le operazioni e dopo che l'operazione viene eseguita l'oggetto di struttura o classe verrà distrutto.
Esempio # 02:
In questo esempio, abbiamo cercato di spiegare in dettaglio il costruttore unico. Abbiamo anche cercato di creare un puntatore unico in modo diverso in modo da poter capire le diverse sintassi e approcci per creare puntatori unici. Per eseguire questo esempio, abbiamo creato una classe denominata "UniquePtr". In questa classe, abbiamo un costruttore di questa classe e di un distruttore. Nell'esempio precedente, abbiamo spiegato che possiamo fare qualunque operazione vogliamo nel costruttore. In questo esempio, abbiamo cercato di farlo per darti un'esperienza pratica.
Quindi, prima nel costruttore, abbiamo stampato "in costruttore" per far sapere all'utente che al momento siamo nel nostro costruttore. Successivamente, abbiamo dichiarato due numeri interi "X" e "Y" che contengono rispettivamente i valori di "2" e "3". Dopodiché, abbiamo dichiarato un'altra variabile che è anche un numero intero: "Z". Abbiamo riassunto o aggiunto i valori di "x" e "y" e abbiamo memorizzato l'output nel numero intero "z". Nella riga numero 13, abbiamo stampato "operazione eseguita" e abbiamo anche stampato il valore di "z" contro di essa in modo da poter far sapere all'utente che l'operazione viene eseguita e il valore dopo l'operazione è il seguente.
Nel nostro distruttore, abbiamo semplicemente stampato "in distruttore". Nel metodo principale, abbiamo semplicemente creato il puntatore unico e superato il nome della classe in modo che possa capire a quale memoria deve indicare. Ora eseguiremo il nostro codice per verificare l'output.
#includere#includere
Utilizzo dello spazio dei nomi std;
Classe UniquePtr
pubblico:
Unfeptr ()
cout<<”In constructor”<
int y = 3;
int z = x + y;
cout<<”Operation Performed = “<
~ UniquePtr ()
cout<<”In Destructor”<
;
int main ()
std :: univoco_ptr x = std :: univoco_ptr (new uniqueptr);
restituzione 0;
Dopo l'esecuzione del nostro codice, quello che segue è l'output che otterremo dal sistema. Una cosa da spiegare qui è che, nel nostro metodo principale, non abbiamo creato alcun oggetto della classe per accedervi. Invece, abbiamo creato solo un puntatore unico e lo abbiamo puntato verso la nostra classe. Il sistema ha stampato "in costruttore", il che significa che è andato nel costruttore e l'altra linea stampata spiega anche che il sistema ha eseguito l'operazione di addizione sui numeri interi e stampato il valore contro il messaggio stampato. Infine, il compilatore si è spostato all'interno del distruttore, ha stampato il messaggio e distrutto l'oggetto della classe. Una cosa da notare qui è che non abbiamo creato o eliminato il mucchio di memoria qui. Tutta questa cosa è stata fatta dal nostro puntatore unico.
Conclusione
In questa guida, abbiamo discusso di un tipo di puntatore intelligente che è un puntatore unico. I puntatori unici sono puntatori intelligenti che ci aiutano con l'allocazione della memoria e la gestione della memoria. Quindi, per capire i suggerimenti unici abbiamo spiegato per la prima volta i puntatori intelligenti e i puntatori unici teoricamente. Dopodiché, abbiamo spiegato la sintassi di puntatori unici. Molteplici esempi sono stati eseguiti in diversi scenari per far capire al lettore i puntatori unici praticamente.