Introduction aux Pointeurs Partagés

Tout comme un pointeur unique, un pointeur partagé est utilisé pour allouer et conserver l'adresse d'un objet alloué dynamiquement. Le principal facteur de différenciation entre les deux types de pointeurs est qu'un pointeur partagé est partageable par conception. Il peut avoir en toute sécurité plus d'un propriétaire. En fait, il ne devrait être utilisé que lorsque vous avez besoin qu'un objet ait plusieurs propriétaires.

Comment fonctionnent les pointeurs partagés ?

Contrairement aux pointeurs uniques, les pointeurs partagés maintiennent un compteur de références. Le compteur de références d'un pointeur partagé suit le nombre de pointeurs partagés qui référencent (possèdent) actuellement le même objet.

Lorsqu'un pointeur partagé sort de la portée, ou est explicitement réinitialisé, le compteur de références est automatiquement décrémenté. Dès que le compteur de références atteint 0, cela signifie qu'aucun pointeur partagé ne référence plus l'objet, et la mémoire de l'objet est automatiquement désallouée.

shared_pointer


              1234567891011121314151617181920212223242526272829303132333435363738394041
            
#include <iostream>

template <typename T>
class SharedPointer {
public:
    explicit SharedPointer(T* ptr = nullptr) 
        : pointer(ptr), reference_count(new int(1)) {}

    SharedPointer(const SharedPointer& other)
        : pointer(other.pointer), reference_count(other.reference_count) 
    {
        (*reference_count)++;
    }

    SharedPointer& operator=(const SharedPointer& other) {
        if (this != &other) {
            if (--(*reference_count) == 0) {
                delete pointer;
                delete reference_count;
            }
            pointer = other.pointer;
            reference_count = other.reference_count;
            (*reference_count)++;
        }
        return *this;
    }

    ~SharedPointer() 
    {
        if (--(*reference_count) == 0) {
            delete pointer;
            delete reference_count;
        }
    }

    T* operator->() const { return pointer; }
    T& operator*() const { return *pointer; }
private:
    T* pointer;
    int* reference_count;
};

C'est un moyen infaillible d'assurer une propriété partagée sécurisée des données dynamiques. En effet, même lors du partage de données, le programme est moins susceptible aux fuites/corruptions de mémoire, et vous n'avez pas besoin d'appeler manuellement delete.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 1