C++ Academy · Aula

Padrões de tratamento de erros

Componha optional e expected

Padrões de tratamento de erros é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Duas Ferramentas, Um Objetivo

std::optional e std::expected substituem valores sentinela sujeitos a erros. Nesta lição, você verá padrões para combiná-los e compô-los de forma organizada.

Retorno Antecipado quando Vazio

Um padrão simples e legível: verifique o valor opcional e saia antecipadamente se ele estiver vazio, antes de continuar.

#include <iostream>
#include <optional>
std::optional<int> parse(bool ok) { return ok ? std::optional<int>(5) : std::nullopt; }
int main() {
    auto v = parse(true);
    if (!v) { std::cout << "no value\n"; return 0; }
    std::cout << *v + 1 << "\n";
}

De Opcional para Resultado Esperado

Converta um valor opcional ausente em um erro descrito quando o chamador precisar saber o motivo.

#include <expected>
#include <optional>
#include <string>
std::expected<int, std::string> require(std::optional<int> o) {
    if (o) return *o;
    return std::unexpected("value missing");
}
int main() {}

Encadeamento com value_or

Quando várias consultas alimentam um único resultado, value_or permite fornecer valores padrão diretamente, sem condicionais if aninhadas.

#include <iostream>
#include <optional>
int setting(std::optional<int> user, int fallback) {
    return user.value_or(fallback);
}
int main() {
    std::cout << setting(std::nullopt, 42) << "\n";
}

Propagando Erros para Cima

Com std::expected, uma função pode inspecionar uma chamada secundária e encaminhar o erro dela sem alterações, formando um fluxo de erros.

#include <expected>
#include <string>
using R = std::expected<int, std::string>;
R step1(bool ok) { return ok ? R(2) : R(std::unexpected("step1 failed")); }
R run(bool ok) {
    auto r = step1(ok);
    if (!r) return std::unexpected(r.error());
    return *r * 10;
}
int main() {}

Encadeamento Monádico com and_then

O and_then do C++23 encadeia operações que retornam um valor opcional ou esperado, interrompendo a sequência na primeira falha, sem uma cascata manual de condicionais if.

transform para Mapeamento

transform aplica uma função comum ao valor de sucesso e deixa os erros ou a ausência inalterados, mapeando apenas o caminho de sucesso.

or_else para Recuperação

or_else executa uma alternativa que pode fornecer um valor substituto ou um erro alternativo quando o valor original estiver ausente ou tiver falhado.

Escolhendo entre os Dois

Use opcional quando a ausência não precisar de explicação, como em uma falha de cache. Use esperado quando o chamador precisar distinguir os motivos da falha, como erros de análise e de permissão.

Evite Sentinelas Mistos

Não misture códigos de erro antigos com valores opcionais ou esperados na mesma interface de programação. Escolha uma estratégia consistente para que os chamadores tratem as falhas de maneira uniforme.

Mantenha os Erros Tipados

Prefira uma enumeração ou uma estrutura pequena para o tipo de erro, em vez de textos simples, quando as falhas forem verificadas programaticamente; os textos são mais adequados para mensagens destinadas às pessoas.

Verificação Rápida

Verifique sua compreensão dos padrões de tratamento de erros.

Recapitulação

Você aprendeu padrões de tratamento de erros:

O retorno antecipado em caso de ausência ou erro mantém o código linear.
Converta um valor opcional em um resultado esperado quando for necessário informar um motivo.
Faça a composição com and_then, transform e or_else (C++23).
Mantenha a consistência; evite misturar valores sentinela com valores opcionais ou esperados.

Perguntas Frequentes

A aula “Padrões de tratamento de erros” é grátis?

Sim — o texto completo de “Padrões de tratamento de erros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Padrões de tratamento de erros”?

Componha optional e expected Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Padrões de tratamento de erros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy