Tipos de exceção personalizados
Defina suas próprias exceções
Tipos de exceção personalizados é 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.
Por que usar exceções personalizadas
Definir seus próprios tipos de exceção permite que os chamadores capturem seus erros especificamente e transportem dados específicos do domínio junto com o erro.
Derive de std::exception
Baseie suas exceções em std::exception (ou em uma subclasse) para que elas se integrem aos manipuladores padrão e exponham what().
#include <exception>
#include <string>
class ConfigError : public std::exception {
std::string msg;
public:
explicit ConfigError(std::string m) : msg(std::move(m)) {}
const char* what() const noexcept override { return msg.c_str(); }
};Lançando e capturando a exceção
Seu tipo se comporta como qualquer outra exceção: lance-o e capture-o por referência.
#include <iostream>
#include <exception>
#include <string>
class ConfigError : public std::exception {
std::string msg;
public:
explicit ConfigError(std::string m) : msg(std::move(m)) {}
const char* what() const noexcept override { return msg.c_str(); }
};
int main() {
try {
throw ConfigError("missing key");
} catch (const ConfigError& e) {
std::cout << e.what() << "\n";
}
}Reutilize bases padrão
Muitas vezes, você pode derivar de std::runtime_error ou std::logic_error, que já armazenam uma mensagem — menos código repetitivo.
#include <stdexcept>
#include <string>
class NetworkError : public std::runtime_error {
public:
explicit NetworkError(const std::string& m) : std::runtime_error(m) {}
};Transportando dados adicionais
Exceções personalizadas podem conter campos como um código de erro ou o valor problemático, fornecendo mais contexto aos manipuladores.
#include <stdexcept>
#include <string>
class HttpError : public std::runtime_error {
public:
int status;
HttpError(int s, const std::string& m)
: std::runtime_error(m), status(s) {}
};Capturando pela classe base
Como seu tipo deriva de std::exception, um manipulador genérico ainda pode capturá-lo por meio da referência à classe base.
#include <iostream>
#include <stdexcept>
class HttpError : public std::runtime_error {
public:
int status;
HttpError(int s, const std::string& m) : std::runtime_error(m), status(s) {}
};
int main() {
try {
throw HttpError(404, "not found");
} catch (const std::exception& e) {
std::cout << e.what() << "\n";
}
}Crie uma hierarquia de exceções
Agrupe erros relacionados sob uma base comum para que os chamadores possam capturar uma família inteira ou um único tipo específico.
#include <stdexcept>
struct AppError : std::runtime_error { using std::runtime_error::runtime_error; };
struct DbError : AppError { using AppError::AppError; };
struct AuthError: AppError { using AppError::AppError; };Mantenha what() como noexcept
Substitua what() como const noexcept e retorne um armazenamento estável — ele nunca deve lançar uma exceção nem retornar um ponteiro pendente.
Lance por valor
Lance objetos de exceção por valor (por exemplo, throw HttpError(500, "x");). O ambiente de execução gerencia o armazenamento deles durante o desenrolamento.
Documente o que você lança
Inclua os tipos de exceção da sua API no contrato dela para que os chamadores saibam quais capturas escrever.
Mantenha a simplicidade
A maioria dos projetos precisa de apenas um pequeno conjunto de tipos de exceção. Derivar de std::runtime_error cobre a maioria dos casos de forma limpa.
Verificação rápida
Teste sua compreensão das exceções personalizadas.
Recapitulação
Você aprendeu a definir tipos de exceção personalizados derivando de std::exception ou std::runtime_error, transportar dados adicionais, criar hierarquias, manter what() como noexcept e lançar por valor. Mantenha o conjunto pequeno e documentado.
Aprenda C++ com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Tipos de exceção personalizados” é grátis?
Sim — o texto completo de “Tipos de exceção personalizados” é 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 “Tipos de exceção personalizados”?
Defina suas próprias exceções 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 “Tipos de exceção personalizados”?
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
- try, catch, throw
- Segurança contra exceções
- Especificador noexcept
- Tipos de exceção personalizados