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

Les pointeurs faibles sont conçus pour briser les références circulaires. En remplaçant un std::shared_ptr dans une dépendance circulaire par un std::weak_ptr, nous empêchons les objets de prolonger involontairement la durée de vie les uns des autres, permettant ainsi une destruction appropriée.

main.cpp


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

class Node {
public:
    Node() { std::cout << "Node constructed." << std::endl; }
    ~Node() { std::cout << "Node destructed." << std::endl; }

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

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
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Now when node1, node2, and node3 go out of scope, their destructors will be called
}

Le problème de référence circulaire est résolu en changeant next d'un std::shared_ptr à un std::weak_ptr. Suivez les commentaires dans le code pour une compréhension plus claire. Exécutez le code pour confirmer que les destructeurs sont maintenant appelés correctement pas de fuites de mémoire !

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 3

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Contenu du cours

Pointeurs Intelligents C++

1. Introduction aux Pointeurs Intelligents

Comprendre les Pointeurs Allocation Dynamique de Mémoire Le Besoin de Pointeurs Intelligents

2. Pointeurs Uniques

Introduction aux Pointeurs Uniques Déplacement des Pointeurs Uniques Application des Pointeurs Uniques Passer des Pointeurs Uniques Méthodes d'un Pointeur Unique

3. Pointeurs Partagés

Introduction aux Pointeurs Partagés Création et Partage de Shared Pointers Références Circulaires et Shared Pointers

4. Pointeurs Faibles

Introduction aux Pointeurs Faibles Création et Utilisation des Pointeurs Faibles Casser les Références Circulaires avec des Pointeurs Faibles Fonctions Importantes des Weak Pointers

5. Sujets Avancés

Fournir des Destructeurs Personnalisés pour les Pointeurs Intelligents Considérations de Performance avec les Smart Pointers Aperçu des Pointeurs Partagés vs Uniques vs Faibles

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

main.cpp


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

class Node {
public:
    Node() { std::cout << "Node constructed." << std::endl; }
    ~Node() { std::cout << "Node destructed." << std::endl; }

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

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
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Now when node1, node2, and node3 go out of scope, their destructors will be called
}

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 3