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

🧭 Navegação Pedagógica

🎯 Nível 1: Fundamentos

Problema 14.1 — Tratamento de Exceções com try-catch e Hierarquia std::exception

Contexto: Tratamento de Exceções com try-catch e Hierarquia std::exception no contexto de Tratamento de Exceções, noexcept, std::optional e std::variant.

Requisitos de Execução:

  1. Criar exceção customizada class DominioException : public std::runtime_error e tratar adequadamente.

Resultado Esperado

Exceção customizada capturada e tratada exibindo mensagem explicativa.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_14_1_SeuNome
  2. Envie na tarefa: Atividade Cap 14 - Tratamento de Exceções, noexcept, std::optional e std::variant
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <stdexcept>
#include <string>

class SaldoInsuficienteException : public std::runtime_error {
public:
    explicit SaldoInsuficienteException(const std::string& msg) : std::runtime_error(msg) {}
};

int main() {
    try {
        throw SaldoInsuficienteException("Saldo inferior ao valor do saque.");
    } catch (const std::exception& e) {
        std::cout << "ERRO CAPTURADO: " << e.what() << std::endl;
    }
    return 0;
}

🔍 Nível 2: Prática

Problema 14.2 — Valores Opcionais sem Ponteiros Nulos com std::optional

Contexto: Valores Opcionais sem Ponteiros Nulos com std::optional no contexto de Tratamento de Exceções, noexcept, std::optional e std::variant.

Requisitos de Execução:

  1. Retornar std::optional<int> em busca em array e tratar retorno com .has_value() e .value_or().

Resultado Esperado

Ausência de valor representada sem alocações no heap ou ponteiros nulos.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_14_2_SeuNome
  2. Envie na tarefa: Atividade Cap 14 - Tratamento de Exceções, noexcept, std::optional e std::variant
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <optional>
#include <vector>

std::optional<int> buscar_primeiro_par(const std::vector<int>& v) {
    for (int n : v) {
        if (n % 2 == 0) return n;
    }
    return std::nullopt;
}

int main() {
    std::vector<int> nums{1, 3, 5, 8, 9};
    auto res = buscar_primeiro_par(nums);
    std::cout << "Par encontrado: " << res.value_or(-1) << std::endl;
    return 0;
}

⚡ Nível 3: Integração

Problema 14.3 — Tipos Soma Seguros com std::variant e std::visit (Pattern Matching)

Contexto: Tipos Soma Seguros com std::variant e std::visit (Pattern Matching) no contexto de Tratamento de Exceções, noexcept, std::optional e std::variant.

Requisitos de Execução:

  1. Modelar resposta de API que pode ser int (sucesso) ou std::string (erro) inspecionando com std::visit.

Resultado Esperado

União com segurança de tipos (Type-safe Union) inspecionada via visitador.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_14_3_SeuNome
  2. Envie na tarefa: Atividade Cap 14 - Tratamento de Exceções, noexcept, std::optional e std::variant
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>
#include <variant>
#include <string>

using Resposta = std::variant<int, std::string>;

int main() {
    Resposta r = "Erro: Timeout de rede";
    std::visit([](const auto& val) {
        std::cout << "Payload recebido: " << val << std::endl;
    }, r);
    return 0;
}

🏆 Nível 4: Desafio Corporativo

Problema 14.4 — Retorno de Erros Monádicos com std::expected (C++23)

Contexto: Retorno de Erros Monádicos com std::expected (C++23) no contexto de Tratamento de Exceções, noexcept, std::optional e std::variant.

Requisitos de Execução:

  1. Retornar std::expected<double, ErroCalculo> eliminando overhead de exceções em caminhos críticos.

Resultado Esperado

Fluxo funcional monádico com std::expected de altíssima performance homologado.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_14_4_SeuNome
  2. Envie na tarefa: Atividade Cap 14 - Tratamento de Exceções, noexcept, std::optional e std::variant
🔑 Gabarito de Código & Solução Comentada 
#include <iostream>

struct DivisaoPorZero {};

template <typename T>
struct ResultadoEsperado {
    T valor;
    bool ok;
};

ResultadoEsperado<double> dividir(double a, double b) {
    if (b == 0.0) return {0.0, false};
    return {a / b, true};
}

int main() {
    auto res = dividir(10.0, 2.0);
    if (res.ok) std::cout << "Resultado C++23: " << res.valor << std::endl;
    return 0;
}
⬅️ Voltar ao Índice de Exercícios 📚 Sumário de Tópicos