Quebrando Referências Circulares com Weak Pointers

Os ponteiros fracos são projetados para quebrar referências circulares. Ao substituir um std::shared_ptr em uma dependência circular por um std::weak_ptr, evitamos que os objetos estendam involuntariamente a vida útil uns dos outros, permitindo a destruição adequada.

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
}

O problema de referência circular é resolvido ao mudar next de um std::shared_ptr para um std::weak_ptr. Siga os comentários no código para uma compreensão mais clara. Execute o código para confirmar que os destruidores agora são chamados corretamente sem vazamentos de memória!

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 4. Capítulo 3

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Conteúdo do Curso

C++ Smart Pointers

1. Introdução a Ponteiros Inteligentes

Compreendendo Ponteiros Alocação Dinâmica de Memória A Necessidade de Ponteiros Inteligentes

2. Ponteiros Únicos

Introdução aos Ponteiros Únicos Movendo Ponteiros Únicos Aplicação para Ponteiros Únicos Passando Ponteiros Únicos Métodos de um Ponteiro Único

3. Ponteiros Compartilhados

Introdução aos Ponteiros Compartilhados Criando e Compartilhando Shared Pointers Referências Circulares e Shared Pointers

4. Ponteiros Fracos

Introdução a Ponteiros Fracos Criando e Usando Weak Pointers Quebrando Referências Circulares com Weak Pointers Funções Importantes de Ponteiros Weak

5. Tópicos Avançados

Fornecendo Destruidores Personalizados para Smart Pointers Considerações de Desempenho com Smart Pointers Visão Geral Ponteiros Compartilhados vs Únicos vs Weak Pointers

Quebrando Referências Circulares com Weak Pointers

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
}

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 4. Capítulo 3