Esempio 1: dichiarare il puntatore condiviso in modi diversi
Nell'esempio seguente vengono mostrati tre modi diversi per dichiarare un puntatore condiviso. Nel codice è stata dichiarata una classe con un costruttore e un metodo pubblico. 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 puntatore condiviso chiamante. 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 è stato creato assegnando il primo puntatore condiviso. Il Schermo() Il metodo è stato chiamato tre volte utilizzando tre oggetti puntatore condivisi.
//Include le librerie necessarie
#includere
#includere
usingnamespacestd;
//Definisci la classe
classMyClass{
pubblico:
//Dichiara il costruttore
La mia classe() {
costo<<'Il costruttore è chiamato. ';
}
//Dichiara un metodo per stampare il testo
voidDisplay(stringa stringa)
{
costo<<'Il metodo Display() viene chiamato da '<<P<<' puntatore. ';
}
};
intmain()
{
// Inizializza shared_ptr senza chiamare il costruttore
shared_ptr p1=make_shared();
p1->Schermo('primo');
// Inizializza shared_ptr chiamando costruttore
shared_ptr p2=shared_ptr(newMyClass);
p2->Schermo('secondo');
// Inizializza shared_ptr per assegnazione
shared_ptr p3=p1;
p3->Schermo('Terzo');
ritorno0;
}
Produzione:
Il seguente output apparirà dopo aver eseguito il codice sopra. Il costruttore ha chiamato solo al momento della creazione del secondo oggetto. Quindi, il messaggio del costruttore è stato stampato una sola volta:
Esempio 2: stampare la posizione del puntatore condiviso memorizzato
Il puntatore condiviso della funzione get() viene utilizzato per restituire la posizione del puntatore memorizzata e condivisa. L'esempio seguente stamperà la posizione dei puntatori condivisi archiviati creati dalla classe e dalla funzione. Qui è stata definita una classe con un costruttore da utilizzare per creare 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 utilizzando la funzione e il terzo puntatore condiviso è stato creato assegnando il primo puntatore.
//Include le librerie necessarie#includere
#includere
usingnamespacestd;
//Definisci la classe
classMyClass
{
pubblico:
//Dichiara il costruttore
La mia classe() {
costo<<'Il costruttore è chiamato. ';
}
};
//Definisci la funzione per inizializzare il puntatore
voidInit_shared_ptr()
{
shared_ptr p2(newMyClass);
costo<<p2.ottenere() <<' ';
}
intmain()
{
// Inizializza shared_ptr chiamando costruttore
shared_ptr p1=shared_ptr(newMyClass);
costo<<p1.ottenere() <<' ';
// Inizializza shared_ptr chiamando function
Init_shared_ptr();
// Inizializza shared_ptr per assegnazione
shared_ptr p3=p1;
costo<<p3.ottenere() <<' ';
ritorno0;
}
Produzione:
Il seguente output simile apparirà dopo aver eseguito il codice sopra. Nell'output, il valore restituito dalla funzione get() per il primo e il terzo puntatore condiviso è lo stesso. Tuttavia, il secondo puntatore condiviso è diverso:
Esempio 3: contare gli oggetti puntatori condivisi
L'esempio seguente illustra un modo per contare il numero di oggetti puntati da un puntatore condiviso dopo aver creato e distrutto il puntatore. Nel codice è stata dichiarata una classe con un costruttore. 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 puntati da entrambi i puntatori condivisi prima e dopo aver chiamato la funzione reset() è stato stampato in seguito.
//Include le librerie necessarie#includere
#includere
usingnamespacestd;
//Definisci la classe
classMyClass{
pubblico:
//Dichiara il costruttore
La mia classe() {
costo<<'Il costruttore è chiamato. ';
}
};
intmain()
{
// Inizializza il primo shared_ptr chiamando constructor
shared_ptr p1(newMyClass);
//Mostra il numero di oggetti shared_ptr dal primo puntatore
costo<<'p1 che punta a'<<p1.use_count() <<' oggetto(i). ';
//Inizia il secondo shared_ptr usando il primo shared_ptr
shared_ptr p2(p1);
//Visualizza il numero di oggetti shared_ptr dal primo e dal secondo puntatore
costo<<'p2 che punta a'<<p2.use_count() <<' oggetto(i). ';
costo<<'p1 che punta a'<<p1.use_count() <<' oggetto(i). ';
//Rimuove la proprietà del primo puntatore dall'oggetto shared_ptr
p1.Ripristina();
//Mostra il numero di oggetti shared_ptr dal secondo puntatore
costo<<'p2 che punta a'<<p2.use_count() <<' oggetto(i). ';
ritorno0;
}
Produzione:
Il seguente output apparirà dopo aver eseguito il codice sopra. Il primo puntatore, p1 , punta a un oggetto dopo la creazione. Dopo aver creato il secondo puntatore, p2 , utilizzando il primo puntatore, p1 , entrambi i puntatori puntano a 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 punta a un solo oggetto.
Conclusione:
Gli scopi dell'utilizzo di un puntatore condiviso in C++ sono stati spiegati in questo tutorial utilizzando semplici esempi. Creazione di puntatori condivisi in modi diversi, acquisizione della posizione del puntatore condiviso memorizzata e conteggio del numero di oggetti puntati dai puntatori condivisi. Spero che i programmatori C++ saranno in grado di utilizzare il puntatore condiviso nel loro codice dopo aver letto questo tutorial.