Création et Partage de Shared Pointers

Tout comme les pointeurs uniques, nous pouvons créer des pointeurs partagés de deux manières : en utilisant std::make_shared ou l'opérateur new. Ce dernier est déconseillé, mais pour bien comprendre, nous couvrirons les deux approches.

L'approche recommandée

La manière recommandée de créer un pointeur partagé est d'utiliser la fonction std::make_shared. Cette approche est généralement plus efficace et expressive par rapport à l'utilisation de new. Elle alloue la mémoire pour l'objet et le bloc de contrôle (compte de référence) en une seule étape. Par exemple :

La ligne ci-dessus alloue un entier dynamique et initialise également un pointeur partagé vers celui-ci avec un compteur de références de 1.

L'approche déconseillée

Vous pouvez également créer des pointeurs partagés en utilisant new, mais cette méthode est déconseillée car elle n'est ni expressive ni efficace. La syntaxe pour cette approche nécessite de passer l'objet au constructeur du pointeur partagé.

Dans le code ci-dessus, nous allouons un entier dynamique puis le passons au constructeur du pointeur partagé. Cependant, le bloc de contrôle (compte de références) sera initialisé à l'intérieur du constructeur.

Cela signifie que nous effectuons deux initialisations distinctes, ce qui est inefficace et sujet à erreur.

Passer des pointeurs partagés

Les pointeurs partagés sont conçus pour un partage sécurisé. Explorons quelques façons de les transmettre.

Par affectation directe

Vous pouvez partager un pointeur partagé en l'affectant directement à un autre pointeur partagé. Cela augmente le compte de références.

Dans le code ci-dessus, nous allouons un entier dynamique qui est possédé par ptr1. À la ligne suivante, nous créons un autre pointeur partagé ptr2 qui commence également à référencer le même entier dynamique.

Retourner d'une fonction

Lorsque vous retournez un pointeur partagé d'une fonction de la manière suivante, l'appelant en reçoit la propriété.

Dans la fonction ci-dessus, nous allouons un entier dynamique à l'intérieur d'une fonction, puis transférons sa propriété à l'appelant.

Partager des objets personnalisés

Il est également possible de partager des objets personnalisés en utilisant des pointeurs partagés. Considérez cet exemple :

main


              123456789101112131415161718192021222324
            
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass(int value) : data(value) {} //constructor

    int getData() { return data; }
private:
    int data;
};

int main() 
{
    // Creating a shared pointer to a custom object using make_shared
    std::shared_ptr<MyClass> obj1 = std::make_shared<MyClass>(42);

    // Creating another shared pointer that shares ownership with obj1
    std::shared_ptr<MyClass> obj2 = obj1;

    // Both obj1 and obj2 now own the  same custom object
    std::cout << "Data from obj1: " << obj1->getData() << std::endl; //prints 42
    std::cout << "Data from obj2: " << obj2->getData() << std::endl; //also prints 42
}

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2