Puntatore intelligente in C ++
Puntatore intelligente vs puntatore normale
I due principali problemi dell'uso di puntatori regolari sono:
UN. Il puntatore regolare non può gestire in modo efficiente l'utilizzo della memoria.
B. Non può rilasciare l'oggetto di memoria quando non vengono utilizzati nel programma.
C. Poiché il puntatore normale non può allocare la memoria dell'oggetto, se il puntatore viene rimosso dal programma, l'indirizzo dell'oggetto di memoria che è indicato dal puntatore non viene trovato. Di conseguenza, perdita di memoria accade.
Per questo, utilizziamo il puntatore intelligente sul puntatore normale. I vantaggi dei puntatori intelligenti rispetto ai suggerimenti regolari sono:
UN. Gestisce automaticamente la memoria.
B. Ha rilasciato la memoria dell'oggetto quando non sono utilizzati nel programma.
C. DE alloca la memoria dell'oggetto quando il puntatore esce dall'ambito nel programma.
D. Il puntatore intelligente viene utilizzato in C ++ per allocare gli oggetti, attraversando i diversi tipi di struttura dei dati e gestisce diversi tipi di espressione di lambda per passare all'interno della funzione.
e. Rende il nostro programma molto sicuro e sicuro. Di conseguenza, il programma diventa molto semplice da capire e diventa più facile da debug.
Diversi tipi di puntatori intelligenti
Normalmente, ci sono tre tipi di puntatori intelligenti disponibili in C++. Sono:
UN. Unico
B. Condiviso
C. Debole.
Ne discuteremo ciascuno di essi di seguito.
UN. Puntatore unico
UN. Il puntatore unico tiene un puntatore a un oggetto. Rilascia la memoria dell'oggetto quando esce dall'ambito.
B. Una delle caratteristiche uniche del puntatore unico è che c'è solo una copia di un oggetto presente nella memoria. Nessun'altra risorsa può indicare quel particolare oggetto.
C. Se sono disponibili molte risorse per un oggetto nel codice, si verifica un errore di tempo di compilazione.
Esempio di programmazione 1:
#includere#includere
Utilizzo dello spazio dei nomi std;
Class Square
lato int;
pubblico:
Quadrato (int s)
lato = s;
Int Area ()
restituire (lato*lato);
;
int main ()
univoco_ptr p1 (nuovo quadrato (2));
cout< area () <
Produzione:
Spiegazione:
Qui, abbiamo creato una classe chiamata Square. All'interno della classe, viene dichiarato un lato variabile e chiama il costruttore per inizializzare il valore della variabile laterale. Ora, abbiamo definito una funzione denominata area che restituisce il valore dell'area.
All'interno della funzione principale (), abbiamo dichiarato un puntatore unico chiamato univoco_ptr. Ora abbiamo creato un puntatore P1 che punta l'oggetto del quadrato di classe e all'interno della sua parentesi, passiamo un valore 2.
Ora se stampiamo l'area attraverso il puntatore p1 come p1-> area (), mostra che l'area del quadrato è 4.
B. Puntatore condiviso
UN. Il puntatore condiviso può essere applicato nel programma quando vogliamo assegnare un puntatore a più risorse degli oggetti.
B. Il puntatore condiviso è un indirizzo generato dall'indirizzo puntatore intelligente, che può essere utilizzato per archiviare e passare un riferimento oltre l'ambito di ambito di una funzione.
C. È molto utile in OOP (programma orientato agli oggetti). Per archiviare un puntatore come variabile membro, viene utilizzato un puntatore condiviso.
D. Il puntatore condiviso non verrà eliminato fino a quando tutte le risorse non avranno completato il loro compito.
Esempio di programmazione 2:
#includere#includere
Utilizzo dello spazio dei nomi std;
Class Square
lato int;
pubblico:
Quadrato (int s)
lato = s;
Int Area ()
restituire (lato*lato);
;
int main ()
condiviso_ptrp1 (nuovo quadrato (2));
// Introduzione del puntatore condiviso;
condiviso_ptrp2;
P2 = p1;
cout
Produzione:
Spiegazione:
Questo esempio di programmazione 2 è la continuazione dell'esempio di programmazione 1. All'interno della funzione principale (), abbiamo introdotto il puntatore condiviso. Usando il puntatore P1, abbiamo creato l'oggetto della classe quadrata. Lo stesso oggetto è indicato dal valore p2-> area () e p1-> area (). Entrambi mostrano l'area della piazza è 4.
C. Puntatore debole
UN. Il puntatore debole è un caso speciale di puntatore da utilizzare con i puntatori condivisi.
B. Il puntatore debole ha la possibilità di accedere a un oggetto di proprietà di una o più istanza di puntatore condivisa.
C. Non fa parte del conteggio di riferimento.
D. Usiamo il puntatore debole del programma quando vogliamo osservare un oggetto, ma non richiediamo che rimanga vivo.
Esempio di programmazione 3:
#includere#includere
Utilizzo dello spazio dei nomi std;
Class Square
lato int;
pubblico:
Quadrato (int s)
lato = s;
Int Area ()
restituire (lato*lato);
;
int main ()
condiviso_ptrp1 (nuovo quadrato (2));
debole_ptrw1;
debole_ptr W2 (W1);
debole_ptr W3 (P1);
cout<< "w1:" << w1.use_count()<
Produzione:
Spiegazione:
Questo esempio di programmazione 3 è la continuazione dell'esempio di programmazione 2. Qui, abbiamo introdotto un puntatore condiviso chiamato shared_ptr e creato un puntatore P1 per puntare l'oggetto della classe quadrata. Ora abbiamo usato il puntatore debole, debole_ptr quali punti W1 e W2. All'interno del W2, passiamo W1. Abbiamo creato un altro puntatore debole W3 in cui passiamo il puntatore P1.
Ora se stampiamo tutto il W1.use_count () e w2.use_count (), il risultato verrà visualizzato.
Conclusione
Nel discutere in dettaglio il concetto e gli usi del puntatore intelligente, siamo giunti a questa conclusione che il puntatore intelligente è introdotto in C ++ per rimuovere gli svantaggi del normale puntatore. Attraverso il puntatore intelligente, possiamo gestire diversi tipi di proprietari e risorse dell'oggetto in modo molto efficiente. Speriamo che questo articolo sia utile. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.