C++ : Les pointeurs intelligents

Utiliser le pointeur partagé : shared_ptr

TESTEZ LINKEDIN LEARNING GRATUITEMENT ET SANS ENGAGEMENT

Tester maintenant Afficher tous les abonnements
Utilisez le plus polyvalent des pointeurs intelligents. Le pointeur shared_ptr vous permet de gérer de multiples références d'une même ressource.

Transcription

Le pointeur partagé est un pointeur intelligent qui permet de gérer des ressources communes à plusieurs parties du programme. Ces ressources ne peuvent pas être libérées tant qu'il y a une partie du programme qui utilise la ressource. Nous allons voir l'utilisation de ce pointeur partagé au travers d'un programme assez similaire à celui du pointeur unique, il utilise une classe chaine et on créé au travers de make_shared qui est une fonction standard de C++11, un pointeur partagé sur une instance de la classe chaine qui va être notre ressource partagée. On lui passe le paramètre du constructeur, il appelle le constructeur pour nous, et le met dans a. Maintenant, a donc s'assure de l'existence de cette ressource et de sa libération quand on n'en a plus besoin. Prenons l'exemple de l'exécution, on a bien la création de notre ressource, chaine(Pique) ici, mais lorsque l'on va faire un reset c'est-à-dire définir une nouvelle ressource chaine(Coeur) qui va être désignée par a, a va s'assurer que Pique qui n'est plus référencé par aucune partie du programme soit bien libéré, on le voit ici au traver de l'appel au destructeur de chaine ~chaine() : Pique. On a aussi, et ça s'est la grande différence avec le pointeur unique puisqu'il faisait la même chose sur une ressource unique, mais là comme on a une ressource partagée, si maintenant je créé une autre référence sur la même ressource que a, donc ici on le voit je créé une autre référence sur Coeur et ben je vais avoir une deuxième référence sur la même ressource. Ici, on voit a et b qui contiennent Coeur, avec le log_COND je vérifie ma condition, on va avoir donc a et b qui sont bien égaux vrai sur cette égalité, bien sûr les contenus de a et les contenus de b sont les mêmes, puisque a et b désignent la même ressource qui est Coeur. Le pointeur partagé donc permet d'avoir plusieurs références sur la même ressource, ici a et b, je peux consulter le nombre de ces références. Donc là on va rajouter dans notre programme un affichage de ce nombre de références on peut le faire au travers d'une fonction qui est accessible sur l'un des deux pointeurs partagés. Donc ici use_count. Et donc si je lance mon nouveau programme ici, je constate bien la présence du 2 ici qui est l'affichage du nombre de références sur Coeur. J'ai deux pointeurs partagés qui ... deux références à Coeur ... deux pointeurs partagés qui référencent Coeur. Voilà alors on peut aller plus loin bien sûr, on peut laisser b le seul maître de la gestion de cette ressource Coeur et donner à a une autre référence par exemple ici Carreau. Et donc si j'affiche aussi le nombre de références sur Carreau, je vais avoir donc ici, une référence sur Carreau, b a sa référence sur Coeur, et si je compare a et b, a et b ne désignent plus la même ressource donc c'est faux, et le contenu de a et le contenu de b sont différents bien sûr puisqu'ils ne désignent plus la même ressource et que le contenu est différent. Donc le pointeur partagé permet une gestion souple des ressources, on le voit aussi en-dessous, au travers de l'appel à la méthode swap qui va permettre d'inverser les ressources gérées par a et b, donc là encore si on exécute, on voit qu'on avait a qui gérait la ressource Carreau, b qui gérait la ressource Coeur, et maintenant après le swap, on a a qui gère la ressource Coeur et b qui gère la ressource Carreau. Ce qui n'est pas la même chose que lorsque l'on va faire un swap entre le contenu de a et le contenu de b auquel cas là, on va avoir quelque chose de plus complexe qui se passe puisque on a des chaines qui vont se déplacer en utilisant les méthodes de déplacement et de permutation qui existent au niveau de notre objet : les constructeurs de déplacement, les opérateurs d'affectation ici on le voit au travers de l'opérateur d'affectation, des choses qui se font quand on manipule les objets eux-mêmes. On voit aussi une gestion intelligente de la mémoire puisqu'on a les deux destructeurs qui sont appelés à la fin de notre programme puisque nos ressources ne sont plus utilisées par aucune partie du programme. Ce qui est intéressant de noter surtout c'est que ces ressources peuvent être gérées de façon plus efficace si on fait un swap directement entre les deux pointeurs partagés et non pas entre les objets pointés comme on pourrait le faire. Alors ici donc si j'arrête le programme et je relance avec ma modification, voilà j'ai une gestion beaucoup plus simple du swap ici, qui va être juste d'inverser, on n'a plus d'appel aux destructeurs, aux constructeurs de déplacement ou aux opérateurs d'affectation. Donc le pointeur partagé est un bon moyen de simplifier votre utilisation de ressources partagées, tout en gardant une sécurité sur la gestion mémoire qui est sous-jacente.

C++ : Les pointeurs intelligents

Utilisez les pointeurs intelligents et gérez efficacement vos ressources et allocations de mémoire en C++. Choisissez le type de pointeur intelligent en fonction de vos besoins.

29 min (9 vidéos)
Aucun commentaire n´est disponible actuellement
 
Logiciel :
Spécial abonnés
Date de parution :24 oct. 2016

Votre formation est disponible en ligne avec option de téléchargement. Bonne nouvelle : vous ne devez pas choisir entre les deux. Dès que vous achetez une formation, vous disposez des deux options de consultation !

Le téléchargement vous permet de consulter la formation hors ligne et offre une interface plus conviviale. Si vous travaillez sur différents ordinateurs ou que vous ne voulez pas regarder la formation en une seule fois, connectez-vous sur cette page pour consulter en ligne les vidéos de la formation. Nous vous souhaitons un excellent apprentissage avec cette formation vidéo.

N'hésitez pas à nous contacter si vous avez des questions !