C ++ Shared_ptr

Le shared_ptr est un type de pointeurs intelligents de C ++ qui contient la propriété partagée de l'objet créé par le pointeur. Il partage la propriété de l'objet lors du stockage du pointeur dans un autre objet, et le compteur de référence partagé compte le nombre de propriétaires. Le shared_ptr augmente le compteur de référence par un après avoir copié l'objet et a diminué le compteur de référence par un après avoir détruit l'objet. La mémoire appartenant à l'objet est réaffectée si l'objet appartenant au dernier shared_ptr est détruit, ou le réinitialiser() La fonction est appelée pour attribuer un autre pointeur pour l'objet. Quand le shared_ptr ne possède aucun objet, alors il est appelé un pointeur partagé vide. Différentes utilisations du shared_ptr ont été montrés dans ce tutoriel.

Exemple 1: Déclarer le pointeur partagé de différentes manières

Trois façons différentes de déclarer un pointeur partagé sont présentés 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é sera créé avec le constructeur. Le Afficher() La méthode imprimera des messages en fonction de l'objet de pointeur partagé appelé. Ici, le premier objet de pointeur partagé a été créé sans appeler le constructeur. Le deuxième objet de pointeur partagé a été créé en appelant le constructeur. Le troisième pointeur partagé a créé en attribuant le premier pointeur partagé. Le Afficher() La méthode a été appelée trois fois en utilisant trois objets de pointeur partagé.

// Inclure les bibliothèques nécessaires
#inclure
#inclure
usingNamespacestd;
// définir la classe
classmyclass
public:
// Déclarer le constructeur
Ma classe()
couter<<"The constructor is called.\n";

// déclare une méthode pour imprimer du texte
voidDisplay (String Str)

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

;
int main()

// Initialiser Shared_ptr sans appeler constructeur
shared_ptr p1 = make_shared ();
p1-> affichage ("premier");
// Initialiser Shared_ptr en appelant le constructeur
shared_ptr p2 = shared_ptr (newmyclass);
p2-> affichage ("second");
// Initialiser Shared_ptr par affectation
shared_ptr p3 = p1;
p3-> affichage ("troisième");
return0;

Sortir:

La sortie suivante apparaîtra après avoir exécuté le code ci-dessus. Le constructeur a appelé au moment de la création d'objets du second. Ainsi, le message du constructeur n'a été imprimé qu'une seule fois:

Exemple 2: Imprimez l'emplacement du pointeur partagé stocké

Le pointeur partagé 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 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 attribuant le premier pointeur.

// Inclure les bibliothèques nécessaires
#inclure
#inclure
usingNamespacestd;
// définir la classe
classmyclass

public:
// Déclarer le constructeur
Ma classe()
couter<<"The constructor is called.\n";

;
// Définissez la fonction pour initialiser le pointeur
voidInit_shared_ptr ()

shared_ptr p2 (newmyclass);
couter<
int main()

// Initialiser Shared_ptr en appelant le constructeur
shared_ptr p1 = shared_ptr (newmyclass);
couter<// Initialiser Shared_ptr en appelant la fonction
Init_shared_ptr ();
// Initialiser Shared_ptr par affectation
shared_ptr p3 = p1;
couter<return0;

Sortir:

La sortie similaire suivante apparaîtra après avoir exécuté le code ci-dessus. Dans la sortie, la valeur retournée de la fonction get () pour les première et troisième pointeurs partagés est le même. Cependant, le deuxième pointeur partagé est différent:

Exemple 3: Comptez les objets du pointeur partagé

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éé en utilisant le 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é plus tard.

// Inclure les bibliothèques nécessaires
#inclure
#inclure
usingNamespacestd;
// définir la classe
classmyclass
public:
// Déclarer le constructeur
Ma classe()
couter<<"The constructor is called.\n";

;
int main()

// Initialisez le premier partagé_ptr en appelant le constructeur
shared_ptr p1 (newmyclass);
// Affiche le nombre d'objets partagés par le premier pointeur par le premier pointeur
couter<<"p1 pointing to "<< p1.use_count() <<" object(s).\n";
// Initialise le deuxième partagé_ptr en utilisant le premier partagé_ptr
shared_ptr p2 (p1);
// Affiche le nombre d'objets partagés par les premier et deuxième pointeurs
couter<<"p2 pointing to "<< p2.use_count() <<" object(s).\n";
couter<<"p1 pointing to "<< p1.use_count() <<" object(s).\n";
// supprime la propriété du premier pointeur de l'objet partagé_ptr
P1.réinitialiser();
// Affiche le nombre d'objets partagés_ptr par le deuxième pointeur
couter<<"p2 pointing to "<< p2.use_count() <<" object(s).\n";
return0;

Sortir:

La sortie suivante apparaîtra après avoir exécuté le 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, Utilisation du 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 en utilisant des exemples simples. Créer des pointeurs partagés de différentes manières, obtenir un 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.