C++ Academy · Lección

Tipos de excepciones personalizados

Defina sus propias excepciones

Tipos de excepciones personalizados es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Por qué usar excepciones personalizadas?

Definir sus propios tipos de excepción permite a los consumidores capturar específicamente sus errores y transportar datos específicos del dominio junto con el error.

Derivar de std::exception

Base sus excepciones en std::exception o en una subclase para integrarlas con los controladores estándar y exponer 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(); }
};

Lanzarla y capturarla

Su tipo se comporta como cualquier otra excepción: láncelo y captúrelo por referencia.

#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";
    }
}

Reutilizar clases base estándar

A menudo puede derivar de std::runtime_error o std::logic_error, que ya almacenan un mensaje, lo que reduce el código repetitivo.

#include <stdexcept>
#include <string>

class NetworkError : public std::runtime_error {
public:
    explicit NetworkError(const std::string& m) : std::runtime_error(m) {}
};

Transportar datos adicionales

Las excepciones personalizadas pueden contener campos como un código de error o el valor que provocó el error, lo que proporciona más contexto a los controladores.

#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) {}
};

Capturar mediante la clase base

Como su tipo deriva de std::exception, un controlador genérico también lo captura mediante la referencia a la clase 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";
    }
}

Crear una jerarquía de excepciones

Agrupe los errores relacionados bajo una clase base común para que los consumidores puedan capturar toda una familia o un ú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; };

Mantener what() como noexcept

Sobrescriba what() como const noexcept y devuelva un búfer estable: nunca debe lanzar excepciones ni devolver un puntero colgante.

Lanzar por valor

Lance los objetos de excepción por valor, por ejemplo, throw HttpError(500, "x");. El entorno de ejecución gestiona su almacenamiento durante el desenrollado.

Documentar qué se lanza

Haga que los tipos de excepción de su API formen parte de su contrato, para que los consumidores sepan qué capturas deben escribir.

Mantener la sencillez

La mayoría de los proyectos solo necesitan unos pocos tipos de excepción. Derivar de std::runtime_error cubre la mayoría de los casos de forma clara.

Comprobación rápida

Compruebe su comprensión de las excepciones personalizadas.

Resumen

Ha aprendido a definir tipos de excepción personalizados derivando de std::exception o std::runtime_error, transportar datos adicionales, crear jerarquías, mantener what() como noexcept y lanzar por valor. Mantenga el conjunto reducido y documentado.

Preguntas frecuentes

¿La lección «Tipos de excepciones personalizados» es gratis?

Sí — el texto completo de «Tipos de excepciones personalizados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos de excepciones personalizados»?

Defina sus propias excepciones Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Tipos de excepciones personalizados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy