Spec Sistemas Com Cpp • Trilha Progressiva em 4 Níveis

🎯 Nível 1: Fundamentos

Problema 10.1 — Posse Exclusiva com std::unique_ptr e std::make_unique

Contexto: Posse Exclusiva com std::unique_ptr e std::make_unique no contexto de Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr).

Requisitos de Execução:

  1. Alocar recurso com auto p = std::make_unique<Produto>() demonstrando liberação automática de memória.

Resultado Esperado

Memória do unique_ptr liberada automaticamente sem vazamentos.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_10_1_SeuNome
  2. Envie na tarefa: Atividade Cap 10 - Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr)
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <memory>

struct Sensor {
    Sensor() { std::cout << "Sensor ligado.\n"; }
    ~Sensor() { std::cout << "Sensor desligado.\n"; }
};

int main() {
    {
        auto s = std::make_unique<Sensor>();
    }
    std::cout << "Fim do escopo.\n";
    return 0;
}

🔍 Nível 2: Prática

Problema 10.2 — Transferência de Posse com std::move em unique_ptr

Contexto: Transferência de Posse com std::move em unique_ptr no contexto de Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr).

Requisitos de Execução:

  1. Transferir a titularidade de um std::unique_ptr para uma função receptora utilizando std::move().

Resultado Esperado

Posse do recurso transferida com sucesso sem cópias de ponteiros.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_10_2_SeuNome
  2. Envie na tarefa: Atividade Cap 10 - Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr)
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <memory>

void consumir_recurso(std::unique_ptr<int> ptr) {
    std::cout << "Recurso consumido na funcao: " << *ptr << std::endl;
}

int main() {
    auto p = std::make_unique<int>(99);
    consumir_recurso(std::move(p));
    if (!p) std::cout << "Ponteiro original esvaziado com sucesso.\n";
    return 0;
}

⚡ Nível 3: Integração

Problema 10.3 — Posse Compartilhada com std::shared_ptr e Contagem de Referência (.use_count())

Contexto: Posse Compartilhada com std::shared_ptr e Contagem de Referência (.use_count()) no contexto de Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr).

Requisitos de Execução:

  1. Compartilhar recurso entre múltiplos donos monitorando a contagem de referências ativas.

Resultado Esperado

Contador de referências incrementado e decrementado conforme posse compartilhada.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_10_3_SeuNome
  2. Envie na tarefa: Atividade Cap 10 - Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr)
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <memory>

int main() {
    auto p1 = std::make_shared<int>(500);
    std::cout << "Refs p1: " << p1.use_count() << std::endl;
    {
        auto p2 = p1;
        std::cout << "Refs compartilhadas: " << p1.use_count() << std::endl;
    }
    std::cout << "Refs apos bloco: " << p1.use_count() << std::endl;
    return 0;
}

🏆 Nível 4: Desafio Corporativo

Problema 10.4 — Quebra de Dependências Cíclicas com std::weak_ptr

Contexto: Quebra de Dependências Cíclicas com std::weak_ptr no contexto de Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr).

Requisitos de Execução:

  1. Modelar nós com referências circulares usando std::weak_ptr para evitar memory leaks permanentes.

Resultado Esperado

Ciclo quebrado e objetos destruídos com sucesso graças ao std::weak_ptr.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_10_4_SeuNome
  2. Envie na tarefa: Atividade Cap 10 - Gerenciamento RAII e Smart Pointers (unique_ptr, shared_ptr)
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <memory>

struct NoB;
struct NoA {
    std::shared_ptr<NoB> b;
    ~NoA() { std::cout << "NoA destruido\n"; }
};
struct NoB {
    std::weak_ptr<NoA> a; // Quebra o ciclo!
    ~NoB() { std::cout << "NoB destruido\n"; }
};

int main() {
    auto a = std::make_shared<NoA>();
    auto b = std::make_shared<NoB>();
    a->b = b;
    b->a = a;
    return 0;
}