Biblioteca de manejo de excepciones de C++ <stdexcept>

<stdexcept>Es un archivo de cabecera de la biblioteca estándar de C++ que define un conjunto de clases de excepción estándar para manejar errores en tiempo de ejecución del programa.

Las excepciones son errores que ocurren durante la ejecución del programa; pueden capturarse y manejarse para evitar la terminación anormal del programa.<stdexcept>El archivo de cabecera define un conjunto destd::exceptionclases de excepción derivadas, que proporcionan una forma estándar de reportar y manejar errores.

Sintaxis

Para usar<stdexcept>las clases de excepción en él, primero necesitas incluir este archivo de cabecera:

#include <stdexcept>

Luego, puedes usar estas clases de excepción para lanzar y capturar excepciones. Por ejemplo:

throw std::runtime_error("An error occurred");

Clases de excepción

<stdexcept>El archivo de cabecera define las siguientes clases de excepción:

  • std::exception: la clase base de todas las clases de excepción estándar.
  • std::bad_exception: se lanza cuando ocurre un error durante el manejo de excepciones.
  • std::bad_alloc: se lanza cuando falla la asignación de memoria.
  • std::bad_cast: se lanza cuando falla la conversión de tipos.
  • std::bad_typeid: cuandotypeidla operación falla, se lanza.
  • std::logic_error: se lanza cuando ocurre un error lógico, por ejemplo, un parámetro de entrada no válido.
  • std::domain_error: se lanza cuando el argumento de una llamada a función no está dentro del rango válido.
  • std::invalid_argument: se lanza cuando el argumento de una llamada a función no es válido.
  • std::length_error: se lanza cuando una operación de contenedor falla debido a una limitación de longitud.
  • std::out_of_range: se lanza cuando se accede a un índice no válido de un contenedor.
  • std::overflow_error: se lanza cuando una operación aritmética produce desbordamiento.
  • std::range_error: se lanza cuando el valor de retorno de una función no está dentro del rango esperado.
  • std::underflow_error: se lanza cuando una operación aritmética produce subdesbordamiento.

Ejemplo

A continuación se muestra un ejemplo que utiliza<stdexcept>un ejemplo simple que demuestra cómo lanzar y capturar excepciones:

Ejemplo

#include <iostream>
#include <stdexcept>

void riskyFunction(int x) {
    if (x < 0) {
        throw std::invalid_argument("Negative value not allowed");
    }
    std::cout << "Processing " << x << std::endl;
}

int main() {
    try {
        riskyFunction(-1);
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    return 0;
}

Salida:

Caught an exception: Negative value not allowed

En este ejemplo,riskyFunctionla función comprueba si el parámetro pasado es negativo; si lo es, lanza unastd::invalid_argumentexcepción. Enmainla función, usamostry-catchun bloque para capturar y manejar esta excepción.

Clases de excepción estándar

std::exception

std::exception es la clase base de todas las clases de excepción estándar. Proporciona una función virtual what() que devuelve una cadena que describe la excepción.

Ejemplo

#include <iostream>
#include <exception>

int main() {
    try {
        throw std::exception();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

std::logic_error

std::logic_error deriva de std::exception y representa errores lógicos del programa. Es una clase base abstracta que normalmente es concretada por clases derivadas.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::logic_error("Logic error occurred");
    } catch (const std::logic_error& e) {
        std::cout << "Caught logic error: " << e.what() << std::endl;
    }
    return 0;
}

std::invalid_argument

std::invalid_argument deriva de std::logic_error y representa que se ha pasado un argumento no válido.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::invalid_argument("Invalid argument provided");
    } catch (const std::invalid_argument& e) {
        std::cout << "Caught invalid argument: " << e.what() << std::endl;
    }
    return 0;
}

std::domain_error

std::domain_error deriva de std::logic_error y representa que el argumento está fuera del dominio válido.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::domain_error("Domain error occurred");
    } catch (const std::domain_error& e) {
        std::cout << "Caught domain error: " << e.what() << std::endl;
    }
    return 0;
}

std::length_error

std::length_error deriva de std::logic_error y representa un error de longitud, como exceder el límite máximo de longitud en operaciones de contenedor.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::length_error("Length error occurred");
    } catch (const std::length_error& e) {
        std::cout << "Caught length error: " << e.what() << std::endl;
    }
    return 0;
}

std::out_of_range

std::out_of_range deriva de std::logic_error y representa un acceso fuera del rango válido.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::out_of_range("Out of range error occurred");
    } catch (const std::out_of_range& e) {
        std::cout << "Caught out of range error: " << e.what() << std::endl;
    }
    return 0;
}

std::runtime_error

std::runtime_error deriva de std::exception y representa errores en tiempo de ejecución del programa. Es una clase base abstracta que normalmente es concretada por clases derivadas.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("Runtime error occurred");
    } catch (const std::runtime_error& e) {
        std::cout << "Caught runtime error: " << e.what() << std::endl;
    }
    return 0;
}

std::range_error

std::range_error deriva de std::runtime_error y representa que el resultado de un cálculo está fuera del rango representable.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::range_error("Range error occurred");
    } catch (const std::range_error& e) {
        std::cout << "Caught range error: " << e.what() << std::endl;
    }
    return 0;
}

std::overflow_error

std::overflow_error deriva de std::runtime_error y representa un error de desbordamiento aritmético.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::overflow_error("Overflow error occurred");
    } catch (const std::overflow_error& e) {
        std::cout << "Caught overflow error: " << e.what() << std::endl;
    }
    return 0;
}

std::underflow_error

std::underflow_error deriva de std::runtime_error y representa un error de subdesbordamiento aritmético.

Ejemplo

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::underflow_error("Underflow error occurred");
    } catch (const std::underflow_error& e) {
        std::cout << "Caught underflow error: " << e.what() << std::endl;
    }
    return 0;
}

Usar clases de excepción personalizadas

Además de las clases de excepción estándar, también podemos definir nuestras propias clases de excepción, heredando de las clases de excepción estándar.

Ejemplo

#include <iostream>
#include <stdexcept>

class MyException : public std::runtime_error {
public:
    MyException(const std::string& message) : std::runtime_error(message) {}
};

int main() {
    try {
        throw MyException("My custom exception occurred");
    } catch (const MyException& e) {
        std::cout << "Caught custom exception: " << e.what() << std::endl;
    }
    return 0;
}

<stdexcept>es un componente importante de la biblioteca estándar de C++. Proporciona un conjunto de clases de excepción estándar que hacen que el manejo de errores sea más consistente y predecible. Al usar estas clases de excepción, puedes escribir código más robusto y fácil de mantener. Para los principiantes, comprender los conceptos básicos de las excepciones y cómo usar<stdexcept>las clases de excepción en él es muy importante.

Otras extensiones