Casser les Références Circulaires avec des Pointeurs Faibles

Comme nous l'avons vu dans la section précédente, les références circulaires se produisent lorsque deux (ou plusieurs) pointeurs partagés se référencent mutuellement dans une boucle, créant un cycle mortel. Cette interdépendance empêche le destructeur de l'objet d'être appelé, car les comptes de référence n'atteignent jamais zéro. Le résultat est une fuite de mémoire très courante qui est devenue la principale raison pour laquelle les pointeurs faibles ont été introduits.

Briser le cycle avec des pointeurs faibles

Les pointeurs faibles sont spécialement conçus pour briser ces cycles. En remplaçant un pointeur partagé dans une référence circulaire par un pointeur faible, nous pouvons nous assurer qu'un des objets n'étend pas artificiellement la durée de vie d'un autre d'une manière qui empêcherait l'un ou l'autre d'être détruit.

Pour mieux comprendre ce concept, réécrivons le problème de référence circulaire de la liste chaînée que nous avons discuté dans la section précédente en utilisant un pointeur faible.

main


              12345678910111213141516171819202122232425262728293031323334
            
#include <iostream>
#include <memory>

class Node {
public:
    // A weak pointer to the next element prevents circular ownership.
    std::weak_ptr<Node> next; 

    // The constructor.
    Node() {
        std::cout << "Node constructed." << std::endl;
    }

    // The destructor.
    ~Node() {
        std::cout << "Node destructed." << std::endl;
    }
};

int main() {
    // Creating three Node objects.
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    std::shared_ptr<Node> node3 = std::make_shared<Node>();

    // Creating a list where the last node's next is a weak pointer,
    // thus preventing a circular reference.
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;

    // Now when node1, node2, and node3 go out of scope, their destructors will be called,
    // and the memory will be properly deallocated.
}

Dans le code ci-dessus, nous avons résolu notre problème de référence circulaire en changeant next d'un pointeur partagé à un pointeur faible. Suivez les commentaires dans le code ci-dessus pour une meilleure compréhension. Et n'oubliez pas d'exécuter le code pour voir les destructeurs être appelés maintenant. Pas de fuites de mémoire !

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 3