C ++ condiviso_ptr

IL condiviso_ptr è un tipo di puntatori intelligenti di C ++ che contiene la proprietà condivisa dell'oggetto creato dal puntatore. Condivide la proprietà dell'oggetto durante la memorizzazione del puntatore in un altro oggetto e il contatore di riferimento condiviso conta il numero di proprietari. IL condiviso_ptr aumenta il contatore di riferimento di uno dopo aver copiato l'oggetto e diminuisce il contatore di riferimento di uno dopo aver distrutto l'oggetto. La memoria di proprietà dell'oggetto è riallocata se l'oggetto di proprietà dell'ultimo condiviso_ptr viene distrutto o il Ripristina() La funzione è chiamata per assegnare un altro puntatore per l'oggetto. Quando il condiviso_ptr non possiede alcun oggetto, quindi è chiamato puntatore condiviso vuoto. Diversi usi del condiviso_ptr sono stati mostrati in questo tutorial.

Esempio 1: dichiarare puntatore condiviso in modi diversi

Nel seguente esempio sono mostrati tre modi diversi per dichiarare un puntatore condiviso. Una classe con un costruttore e un metodo pubblico sono stati dichiarati nel codice. Il costruttore stamperà un messaggio quando viene creato un nuovo oggetto condiviso con il costruttore. IL Schermo() Il metodo stamperà i messaggi in base all'oggetto chiamante puntatore condiviso. Qui, il primo oggetto puntatore condiviso è stato creato senza chiamare il costruttore. Il secondo oggetto puntatore condiviso è stato creato chiamando il costruttore. Il terzo puntatore condiviso ha creato assegnando il primo puntatore condiviso. IL Schermo() Il metodo è stato chiamato tre volte utilizzando tre oggetti puntatore condivisi.

// Includi le librerie necessarie
#includere
#includere
UsingNamesPacestd;
// Definisci la classe
ClassMyclass
pubblico:
// dichiara il costruttore
La mia classe()
cout<<"The constructor is called.\n";

// Dichiara un metodo per stampare il testo
voiddisplay (stringa str)

cout<<"The Display() method is called from the "<< str <<" pointer.\n";

;
intmain ()

// Inizializza shared_ptr senza chiamare il costruttore
condiviso_ptr p1 = make_shared ();
p1-> display ("primo");
// Inizializza shared_ptr chiamando il costruttore
shared_ptr p2 = shared_ptr (newmyclass);
p2-> display ("secondo");
// Inizializza Shared_Ptr per assegnazione
condiviso_ptr p3 = p1;
p3-> display ("terzo");
return0;

Produzione:

Verrà visualizzato il seguente output dopo aver eseguito il codice sopra. Il costruttore ha chiamato solo al momento della creazione di un oggetto. Quindi, il messaggio del costruttore è stato stampato solo una volta:

Esempio 2: stampare la posizione del puntatore condivisa memorizzata

Il puntatore condiviso della funzione get () viene utilizzato per restituire la posizione del puntatore condivisa memorizzata. Il seguente esempio stamperà la posizione dei puntatori memorizzati e condivisi creati dalla classe e dalla funzione. Qui, una classe con un costruttore è stata definita per essere utilizzata per la creazione di un puntatore condiviso. È stata dichiarata una funzione per creare un puntatore condiviso e stampare la posizione del puntatore condiviso utilizzando la funzione get (). In questo codice, il primo puntatore condiviso è stato creato utilizzando la classe, il secondo puntatore condiviso è stato creato usando la funzione e il terzo puntatore condiviso è stato creato assegnando il primo puntatore.

// Includi le librerie necessarie
#includere
#includere
UsingNamesPacestd;
// Definisci la classe
Classmyclass

pubblico:
// dichiara il costruttore
La mia classe()
cout<<"The constructor is called.\n";

;
// Definisci la funzione per inizializzare il puntatore
voidinit_shared_ptr ()

shared_ptr P2 (newmyclass);
cout<
intmain ()

// Inizializza shared_ptr chiamando il costruttore
shared_ptr p1 = shared_ptr (newmyclass);
cout<// Inizializza shared_ptr chiamando la funzione
Init_shared_ptr ();
// Inizializza Shared_Ptr per assegnazione
condiviso_ptr p3 = p1;
cout<return0;

Produzione:

Verrà visualizzato il seguente output simile dopo aver eseguito il codice sopra. Nell'output, il valore restituito della funzione get () per il primo e il terzo puntatori condivisi sono gli stessi. Tuttavia, il secondo puntatore condiviso è diverso:

Esempio 3: conta gli oggetti puntatore condiviso

L'esempio seguente raffigura un modo per contare il numero di oggetti indicati da un puntatore condiviso dopo aver creato e distrutto il puntatore. Una classe con un costruttore è stata dichiarata nel codice. Il primo puntatore condiviso è stato creato utilizzando la classe e il secondo puntatore condiviso è stato creato utilizzando il primo puntatore condiviso. Il numero di oggetti indicati da entrambi i puntatori condivisi prima e dopo aver chiamato la funzione reset () è stato stampato in seguito.

// Includi le librerie necessarie
#includere
#includere
UsingNamesPacestd;
// Definisci la classe
ClassMyclass
pubblico:
// dichiara il costruttore
La mia classe()
cout<<"The constructor is called.\n";

;
intmain ()

// Inizializza il primo shared_ptr chiamando il costruttore
shared_ptr P1 (newmyclass);
// Visualizza il numero di oggetti shared_ptr dal primo puntatore
cout<<"p1 pointing to "<< p1.use_count() <<" object(s).\n";
// Inizializza il secondo condiviso
condiviso_ptr P2 (P1);
// Visualizza il numero di oggetti shared_ptr da parte del primo e del secondo puntatori
cout<<"p2 pointing to "<< p2.use_count() <<" object(s).\n";
cout<<"p1 pointing to "<< p1.use_count() <<" object(s).\n";
// Rimuovi la proprietà del primo puntatore dall'oggetto condiviso_ptr
P1.Ripristina();
// Visualizza il numero di oggetti shared_ptr dal secondo puntatore
cout<<"p2 pointing to "<< p2.use_count() <<" object(s).\n";
return0;

Produzione:

Verrà visualizzato il seguente output dopo aver eseguito il codice sopra. Il primo puntatore, P1, punta a un oggetto dopo la creazione. Dopo aver creato il secondo puntatore, P2, Usando il primo puntatore, P1, Entrambi i puntatori indicano due oggetti per condividere il puntatore. Dopo aver chiamato la funzione reset () per il puntatore, P1, Un oggetto è stato distrutto e il puntatore, P2, ora indica un solo oggetto.

Conclusione:

Gli scopi dell'utilizzo di un puntatore condiviso in C ++ sono stati spiegati in questo tutorial utilizzando esempi semplici. Creazione di puntatori condivisi in diversi modi, ricevere la posizione del puntatore condivisa memorizzata e contando il numero di oggetti indicati dai puntatori condivisi. Spero che i programmatori C ++ siano in grado di utilizzare il puntatore condiviso nel loro codice dopo aver letto questo tutorial.