Quais são os ponteiros inteligentes em C++?

std::unique_ptr, std::shared_ptr, std::weak_ptr.

• std::unique_ptr:

  • Propriedade exclusiva do objeto.
  • Não pode ser copiado, mas pode ser movido (std::move).
  • Remove automaticamente o objeto ao sair do escopo ou destruir unique_ptr.
  • É leve, sem custos adicionais no contador de referências.

  #include <memory>
  
  // Criação de unique_ptr
  std::unique_ptr<int> up1(new int(10));
  
  // Movimentar propriedade
  std::unique_ptr<int> up2 = std::move(up1);
  
  // up1 agora é nullptr
  // up2 possui o objeto
  

• std::shared_ptr:

  • Propriedade compartilhada do objeto.
  • Usa um contador de referências para rastrear quantos shared_ptr apontam para o recurso.
  • O objeto é destruído quando o último shared_ptr que o referencia é destruído.
  • Pode ser copiado e movido.
  • Tem custos adicionais no contador de referências (geralmente alocado separadamente).
  • Pode formar referências cíclicas, levando a vazamentos de memória.

  #include <memory>
  
  // Criação de shared_ptr
  std::shared_ptr<int> sp1 = std::make_shared<int>(20);
  
  // Cópia de propriedade
  std::shared_ptr<int> sp2 = sp1; // O contador de referências aumenta
  
  // sp1 e sp2 possuem o objeto
  

• std::weak_ptr:

  • Não possui o objeto.
  • Representa uma "referência fraca" ao objeto, gerenciada por um ou vários shared_ptr.
  • Usada para evitar referências cíclicas entre shared_ptr.
  • Não aumenta o contador de referências do objeto.
  • Para acessar com segurança o objeto, converta para shared_ptr usando o método lock(). Se o objeto já foi excluído, lock() retornará um shared_ptr vazio.

  #include <memory>
  
  // Criação de shared_ptr
  std::shared_ptr<int> sp = std::make_shared<int>(30);
  
  // Criação de weak_ptr a partir de shared_ptr
  std::weak_ptr<int> wp = sp;
  
  // Verificação e uso do objeto
  if (auto shared_from_weak = wp.lock()) {
      // Acesso ao objeto via shared_from_weak
  } else {
      // O objeto já foi excluído
  }