Médio C++

Compartilhamento com shared_ptr

Enunciado

Crie um std::shared_ptr<std::string> com o valor "compartilhado". Faça uma cópia e imprima o use_count antes e depois de a cópia sair de escopo.

Requisitos

  • Usar std::make_shared<std::string>("compartilhado").
  • Imprimir use_count() com a cópia ativa (deve ser 2).
  • Imprimir use_count() após a cópia ser destruída (deve ser 1).

Código inicial

#include <iostream>
#include <memory>
#include <string>

int main() {
    // seu código aqui
    return 0;
}

Saída esperada

use_count com copia: 2
use_count sem copia: 1
Ver dica

Coloque a cópia dentro de um bloco { } para que ela seja destruída ao final dele.

Mostrar solução 
#include <iostream>
#include <memory>
#include <string>

int main() {
    // Cria shared_ptr para string
    auto sp = std::make_shared<std::string>("compartilhado");
    {
        auto copia = sp; // incrementa contador
        std::cout << "use_count com copia: " << sp.use_count() << '\n';
    } // copia destruida, contador decrementa
    std::cout << "use_count sem copia: " << sp.use_count() << '\n';
    return 0;
}

Passo a passo

  1. std::make_shared<std::string>("compartilhado") aloca a string e cria um shared_ptr com contador 1.
  2. Dentro do bloco, auto copia = sp; copia o shared_ptr, incrementando o contador para 2.
  3. sp.use_count() retorna 2, que é impresso.
  4. Ao final do bloco, copia é destruída, decrementando o contador para 1.
  5. Fora do bloco, sp.use_count() retorna 1.

Por que funciona

O shared_ptr mantém um bloco de controle com o contador de referências. Cada cópia incrementa, cada destruição decrementa. Quando chega a zero, o objeto gerenciado é destruído.

Erros comuns

  • Usar new diretamente: std::shared_ptr<std::string> sp(new std::string("...")); funciona, mas é menos eficiente e menos seguro que make_shared.
  • Esquecer que use_count é aproximado em ambientes multithread; não use para lógica de sincronização.
  • Criar dois shared_ptr independentes para o mesmo objeto bruto: auto p = new int; std::shared_ptr<int> a(p); std::shared_ptr<int> b(p); causa double free.

Outra forma de resolver

Poderia usar std::shared_ptr<std::string> sp = std::make_shared<std::string>("compartilhado"); sem auto, mas auto é mais idiomático.

Saída esperada

use_count com copia: 2
use_count sem copia: 1