Exemple 1 : déclarer un pointeur partagé de différentes manières
Trois manières différentes de déclarer un pointeur partagé sont illustrées dans l'exemple suivant. Une classe avec un constructeur et une méthode publique ont été déclarées dans le code. Le constructeur imprimera un message lorsqu'un nouvel objet partagé est créé avec le constructeur. Les Affichage() La méthode imprimera des messages basés sur l'objet pointeur partagé appelant. Ici, le premier objet pointeur partagé a été créé sans appeler le constructeur. Le deuxième objet pointeur partagé a été créé en appelant le constructeur. Le troisième pointeur partagé a été créé en affectant le premier pointeur partagé. Les Affichage() La méthode a été appelée trois fois en utilisant trois objets pointeurs partagés.
//Inclure les bibliothèques nécessaires
#comprendre
#comprendre
utilisation de l'espace de noms;
//Définir la classe
classeMaClasse{
Publique:
//Déclare le constructeur
Ma classe() {
cout<<'Le constructeur est appelé. ';
}
//Déclarer une méthode pour imprimer du texte
voidAffichage(chaîne str)
{
cout<<'La méthode Display() est appelée depuis le '<<p<<' pointeur. ';
}
};
int main()
{
//Initialisation de shared_ptr sans appeler le constructeur
partagé_ptr p1=make_shared();
p1->Affichage('premier');
//Initialisation de shared_ptr en appelant le constructeur
partagé_ptr p2=partagé_ptr(nouveauMaClasse);
p2->Affichage('seconde');
//Initialisation de shared_ptr par affectation
partagé_ptr p3=p1;
p3->Affichage('troisième');
retour0;
}
Sortir:
La sortie suivante apparaîtra après l'exécution du code ci-dessus. Le constructeur n'a appelé qu'au moment de la création du deuxième objet. Ainsi, le message du constructeur n'a été imprimé qu'une seule fois :
Exemple 2 : imprimer l'emplacement du pointeur partagé stocké
Le pointeur partagé de la fonction get() est utilisé pour renvoyer l'emplacement du pointeur partagé stocké. L'exemple suivant imprimera l'emplacement des pointeurs partagés stockés qui sont créés par la classe et la fonction. Ici, une classe avec un constructeur a été définie pour être utilisée pour créer un pointeur partagé. Une fonction a été déclarée pour créer un pointeur partagé et imprimer l'emplacement du pointeur partagé à l'aide de la fonction get(). Dans ce code, le premier pointeur partagé a été créé à l'aide de la classe, le deuxième pointeur partagé a été créé à l'aide de la fonction et le troisième pointeur partagé a été créé en affectant le premier pointeur.
//Inclure les bibliothèques nécessaires#comprendre
#comprendre
utilisation de l'espace de noms;
//Définir la classe
classeMaClasse
{
Publique:
//Déclare le constructeur
Ma classe() {
cout<<'Le constructeur est appelé. ';
}
};
//Définir la fonction pour initialiser le pointeur
voidInit_shared_ptr()
{
partagé_ptr p2(nouveauMaClasse);
cout<<p2.avoir() <<' ';
}
int main()
{
//Initialisation de shared_ptr en appelant le constructeur
partagé_ptr p1=partagé_ptr(nouveauMaClasse);
cout<<p1.avoir() <<' ';
//Initialisation de shared_ptr en appelant la fonction
Init_shared_ptr();
//Initialisation de shared_ptr par affectation
partagé_ptr p3=p1;
cout<<p3.avoir() <<' ';
retour0;
}
Sortir:
La sortie similaire suivante apparaîtra après l'exécution du code ci-dessus. Dans la sortie, la valeur renvoyée par la fonction get() pour les premier et troisième pointeurs partagés est la même. Cependant, le deuxième pointeur partagé est différent :
Exemple 3 : compter les objets pointeurs partagés
L'exemple suivant illustre un moyen de compter le nombre d'objets pointés par un pointeur partagé après avoir créé et détruit le pointeur. Une classe avec un constructeur a été déclarée dans le code. Le premier pointeur partagé a été créé à l'aide de la classe et le deuxième pointeur partagé a été créé à l'aide du premier pointeur partagé. Le nombre d'objets pointés par les deux pointeurs partagés avant et après l'appel de la fonction reset() a été imprimé ultérieurement.
//Inclure les bibliothèques nécessaires#comprendre
#comprendre
utilisation de l'espace de noms;
//Définir la classe
classeMaClasse{
Publique:
//Déclare le constructeur
Ma classe() {
cout<<'Le constructeur est appelé. ';
}
};
int main()
{
// Initialiser le premier shared_ptr en appelant le constructeur
partagé_ptr p1(nouveauMaClasse);
//Affiche le nombre d'objets shared_ptr par le premier pointeur
cout<<'p1 pointant vers '<<p1.use_count() <<' objets). ';
// Initialiser le deuxième shared_ptr en utilisant le premier shared_ptr
partagé_ptr p2(p1);
//Affiche le nombre d'objets shared_ptr par les premier et deuxième pointeurs
cout<<'p2 pointant vers '<<p2.use_count() <<' objets). ';
cout<<'p1 pointant vers '<<p1.use_count() <<' objets). ';
//Supprimer la propriété du premier pointeur de l'objet shared_ptr
p1.réinitialiser();
//Affiche le nombre d'objets shared_ptr par le deuxième pointeur
cout<<'p2 pointant vers '<<p2.use_count() <<' objets). ';
retour0;
}
Sortir:
La sortie suivante apparaîtra après l'exécution du code ci-dessus. Le premier pointeur, p1 , pointe vers un objet après la création. Après avoir créé le deuxième pointeur, p2 , en utilisant le premier pointeur, p1 , les deux pointeurs pointent vers deux objets pour partager le pointeur. Après avoir appelé la fonction reset() pour le pointeur, p1 , un objet a été détruit et le pointeur, p2 , pointe maintenant vers un seul objet.
Conclusion:
Les objectifs de l'utilisation d'un pointeur partagé en C++ ont été expliqués dans ce tutoriel à l'aide d'exemples simples. Créer des pointeurs partagés de différentes manières, obtenir l'emplacement de pointeur partagé stocké et compter le nombre d'objets pointés par les pointeurs partagés. J'espère que les codeurs C++ pourront utiliser le pointeur partagé dans leur code après avoir lu ce tutoriel.