C ++ std faible_ptr

La condition préalable pour étudier le pointeur faible est que nous devons connaître les pointeurs uniques et les pointeurs partagés. Un pointeur unique a une propriété unique. Il détient les objets gérés et ne permet à personne de gérer ces objets. Supposons que nous ayons un objet nommé «P» qui est géré par un pointeur unique. Ensuite, nous ne pouvons pas copier ce pointeur. Dans l'autre cas, pour le pointeur partagé, nous avons également «P» mais nous utilisons un pointeur partagé. Cette fois, vous pouvez copier ce pointeur partagé dans plusieurs variables différentes et nous utiliserons un nombre de références pour compter le nombre de pointeurs intelligents ou pointer vers cet objet géré particulier.

Maintenant, nous pouvons dire que le pointeur unique est pour une propriété unique. Le pointeur partagé est pour la propriété partagée. Et le pointeur faible est pour la non-propriété. Un pointeur faible est également un pointeur intelligent; il ne participera pas du tout à la propriété. C'est une référence à un objet qui est géré par un pointeur partagé. Maintenant, une chose qui peut être coincée dans notre esprit est que si le pointeur faible n'a pas de propriété comme un pointeur unique ou partagé, comment ce pointeur faible sera-t-il géré? Le pointeur n'a rien avec, il prend l'objet géré des pointeurs partagés. Ils sont utilisés pour briser la dépendance circulaire des personnes partagées.

Syntaxe:

La syntaxe pour appliquer un pointeur faible dans le programme est la suivante:

std :: faible_ptr p (nouveau int);

Dans la syntaxe donnée, le type est le type de données que le pointeur faible contrôle.

Exemple 1:

Pour comprendre le pointeur faible d'une meilleure manière, donnons d'abord un exemple afin qu'il nous soit plus facile de comprendre comment cela fonctionne. Dans cet exemple, nous créons un pointeur faible en utilisant les pointeurs partagés et créons le nombre de références en utilisant le pointeur faible. Comme nous l'avons discuté précédemment, le pointeur faible lui-même ne tient pas la propriété; Il faut la propriété d'autres pointeurs pour briser une dépendance circulaire des objets. Maintenant, nous tournant vers notre code où nous incluons d'abord deux fichiers d'en-tête - le premier fichier d'en-tête est la «mémoire» et le deuxième fichier d'en-tête est le «iOStream». Le «iOStream» est utilisé pour permettre au codeur d'effectuer les opérations d'E / S tandis que la «mémoire» est la bibliothèque utilisée pour gérer la mémoire dynamique.

Ensuite, nous nous déplaçons dans la fonction principale où nous définissons un pointeur partagé de type entier et nommez le pointeur «shR_PTR_A». En utilisant le «nouvel» opérateur, nous allouons la mémoire au tas pour int «12». Maintenant, nous déclarons un pointeur faible du type entier et le nommez comme «wk_ptr» auquel nous passons le pointeur partagé. Cela signifie qu'il détient la référence de l'Entier «12». Après l'avoir déclaré avec succès, nous imprimons le nombre de dénombrements que le pointeur faible est appelé à l'aide du «use_count ()» qui est utilisé pour renvoyer le nombre d'instances de pointeur partagées qui gèrent l'objet actuel. Dans cet exemple, nous effectuons cette étape 3 fois en créant les trois objets partagés. À la fin du code, nous renvoyons les valeurs nulles.

#inclure
#inclure
int main()

std :: shared_ptr SHR_PTR_A (NOUVEAU INT (12));
std :: faible_ptr wk_ptr (shr_ptr_a);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr SHR_PTR_B (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr SHR_PTR_C (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
return (0);

Maintenant, vérifions la sortie du code affichée dans l'extrait suivant dans lequel nous imprimons le nombre de références créées. Après la création de chaque référence, nous imprimons le décompte pour cela. Pour la première sortie, il en était un, pour la deuxième sortie, il était de 2, et pour la dernière sortie, c'était 3. Cela signifie que les trois références totales sont créées en utilisant le pointeur faible.

Exemple 2:

Nous effectuons un autre exemple dans lequel nous créons deux classes et les détruisons en utilisant le pointeur faible. Chaque fois que nous accédons à n'importe quel objet ou le supprimons à tout moment par un pointeur intelligent, un pointeur faible est utilisé pour suivre cela. Il est converti en un pointeur partagé comme propriété temporaire. Si nous voulons détruire le pointeur partagé d'origine, la durée de vie de l'objet est étendue jusqu'à ce que nous détruisons le pointeur partagé temporaire.

Maintenant, passons au code où nous incluons d'abord les fichiers d'en-tête. Avant de plonger dans la fonction principale, nous déclarons deux classes - la première est la «class_a» et la seconde est la «class_b». À l'intérieur de la «classe_a», nous définissons d'abord un pointeur faible nommé «bptr» en passant le «class_b» comme paramètre. Ensuite, nous appelons un constructeur et un destructeur pour «class_a». Nous répétons les mêmes étapes pour la «classe_b» dans laquelle nous définissons un pointeur faible et passons un «class_a» comme paramètre. Le constructeur affiche un message de création de la classe. Lorsque la fonction de détruire est appelée, elle affiche le message détruit de la classe.

Après cela, nous sautons dans la fonction principale où nous déclarons les pointeurs partagés nommant «A» et «B» à laquelle nous attribuons une fonction «Make_shared» où nous passons les deux classes en tant que paramètre. La fonction «Make_shared» est utilisée pour allouer et créer tout type d'objet en passant le type de données comme argument. Il renvoie l'objet du pointeur partagé qui est le propriétaire de l'objet et le stocke. Enfin, en utilisant les pointeurs partagés «A» et «B», nous les indexons pour accéder à l'index de mémoire derrière les emplacements indiqués par le «BPTR» et «APTR». Cela signifie que nous attribuons les objets de pointeurs partagés au pointeur faible.

#inclure
#inclure
class class_b;
classe Classe_A

public:
std :: faible_ptrbptr;
Classe A()
std :: cout << "class_a created sucessfully" << std::endl;

~ class_a ()
std :: cout << "class_a destroyed sucessfully" << std::endl;

;
classe Class_B

public:
std :: faible_ptraptr;
class_b ()
std :: cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: cout << "class_b destroyed sucessfully" b-> aptr = a;

Dans l'extrait suivant, la sortie de notre code s'affiche où nous pouvons vérifier que les deux class_and class_b sont créés et détruits avec succès.

Conclusion

Dans cet article, nous avons étudié l'utilisation de pointeurs faibles, comment ils fonctionnent et le but d'utiliser les pointeurs faibles en utilisant plusieurs exemples, y compris le code et la sortie. Les pointeurs faibles jouent un rôle vital dans c++. En coordination avec les pointeurs partagés, les pointeurs faibles aident tout en déclarant ou en initialisant un cycle optimisé pour obtenir les éléments. Ils aident également à l'acquisition de ressources.