Throwing exceptions

Lanzar una excepción transfiere el control a un manejador .

Una excepción puede ser lanzada desde throw expressions , los siguientes contextos también pueden lanzar excepciones:

• funciones de asignación
• dynamic_cast
• typeid
• new expresiones
• biblioteca estándar funciones

Objeto de excepción

Lanzar una excepción inicializa un objeto con storage duration dinámico, llamado exception object .

Si el tipo del objeto de excepción sería uno de los siguientes tipos, el programa está mal formado:

• un tipo incompleto
• un tipo de clase abstracta
• un puntero a un tipo incompleto distinto de (posiblemente calificado cv) void

Construcción y destrucción de objetos de excepción

Dado el tipo del objeto de excepción como T :

• Sea obj un lvalue de tipo const T , la inicialización por copia de un objeto de tipo T desde obj debe estar bien formada.
• Si T es un tipo clase:

• El constructor seleccionado es odr-used .
• El destructor de T es potentially invoked .

La memoria para el objeto de excepción se asigna de manera no especificada. La única garantía es que el almacenamiento nunca será asignado por las funciones de asignación global .

Si un handler termina mediante rethrowing , el control se pasa a otro handler para el mismo objeto de excepción. El objeto de excepción no se destruye en este caso.

throw expresiones throw

Cuando se lanza una nueva excepción, su objeto de excepción se determina de la siguiente manera:

1. Se realizan las conversiones estándar de array-a-puntero y función-a-puntero sobre expression .
2. Sea ex el resultado de la conversión:

• El tipo del objeto de excepción se determina eliminando cualquier calificador cv de nivel superior del tipo de ex .
• El objeto de excepción es copy-initialized desde ex .

Si un programa intenta relanzar una excepción cuando actualmente no se está manejando ninguna excepción, std::terminate será invocado. De lo contrario, la excepción se reactiva con el objeto de excepción existente (no se crea ningún nuevo objeto de excepción), y la excepción ya no se considera capturada.

try
{
    // lanzando una nueva excepción 123
    throw 123;
}
catch (...) // capturar todas las excepciones
{
    // responder (parcialmente) a la excepción 123
    throw; // pasar la excepción a otro manejador
}

Desenrollado de pila

Una vez que el objeto de excepción es construido, el flujo de control retrocede (hacia arriba en la pila de llamadas) hasta que alcanza el inicio de un try bloque , momento en el cual los parámetros de todos los manejadores asociados son comparados, en orden de aparición, con el tipo del objeto de excepción para encontrar una coincidencia . Si no se encuentra ninguna coincidencia, el flujo de control continúa desenrollando la pila hasta el siguiente try bloque, y así sucesivamente. Si se encuentra una coincidencia, el flujo de control salta al manejador correspondiente.

A medida que el flujo de control asciende por la pila de llamadas, se invocan los destructores para todos los objetos con duración de almacenamiento automático que fueron construidos pero aún no destruidos, desde que se ingresó al bloque try correspondiente, en orden inverso al de finalización de sus constructores. Si se lanza una excepción desde un destructor de una variable local o de un temporal utilizado en una sentencia return , también se invoca el destructor del objeto devuelto por la función.

Si se lanza una excepción desde un constructor o (rara vez) desde un destructor de un objeto (independientemente de la duración de almacenamiento del objeto), se llaman los destructores para todos los miembros no estáticos no variantes completamente construidos y clases base, en orden inverso a la finalización de sus constructores. Los miembros variantes de union-like classes solo se destruyen en caso de desenrollado desde el constructor, y si el miembro activo cambió entre la inicialización y la destrucción, el comportamiento es indefinido.

Si la excepción es lanzada desde un constructor que es invocado por una new-expression , la función de desasignación correspondiente deallocation function es llamada, si está disponible.

Este proceso se denomina stack unwinding .

Si cualquier función que es llamada directamente por el mecanismo de desenrollado de pila, después de la inicialización del objeto de excepción y antes del inicio del manejador de excepciones, termina con una excepción, std::terminate es llamado. Tales funciones incluyen destructors de objetos con duración de almacenamiento automático cuyos ámbitos son abandonados, y el copy constructor del objeto de excepción que es llamado (si no es elided ) para inicializar argumentos catch-by-value.

Si se lanza una excepción y no es capturada, incluyendo excepciones que escapan de la función inicial de std::thread , la función principal, y el constructor o destructor de cualquier objeto estático o thread-local, entonces std::terminate es llamado. Es definido por la implementación si ocurre algún desenrollado de pila (stack unwinding) para excepciones no capturadas.

Notas

Al relanzar excepciones, debe usarse la segunda forma para evitar el object slicing en el caso (típico) donde los objetos de excepción utilizan herencia:

try
{
    std::string("abc").substr(10); // lanza std::out_of_range
}
catch (const std::exception& e)
{
    std::cout << e.what() << '\n';
//  throw e; // inicializa por copia un nuevo objeto de excepción de tipo std::exception
    throw;   // relanza el objeto de excepción de tipo std::out_of_range
}

La throw -expression se clasifica como expresión prvalue de tipo void . Como cualquier otra expresión, puede ser una subexpresión en otra expresión, más comúnmente en el operador condicional :

double f(double d)
{
    return d > 1e7 ? throw std::overflow_error("demasiado grande") : d;
}
int main()
{
    try
    {
        std::cout << f(1e10) << '\n';
    }
    catch (const std::overflow_error& e)
    {
        std::cout << e.what() << '\n';
    }
}

Palabras clave

throw

Ejemplo

#include <iostream>
#include <stdexcept>
struct A
{
    int n;
    A(int n = 0): n(n) { std::cout << "A(" << n << ") constructed successfully\n"; }
    ~A() { std::cout << "A(" << n << ") destroyed\n"; }
};
int foo()
{
    throw std::runtime_error("error");
}
struct B
{
    A a1, a2, a3;
    B() try : a1(1), a2(foo()), a3(3)
    {
        std::cout << "B constructed successfully\n";
    }
    catch(...)
    {
        std::cout << "B::B() exiting with exception\n";
    }
    ~B() { std::cout << "B destroyed\n"; }
};
struct C : A, B
{
    C() try
    {
        std::cout << "C::C() completed successfully\n";
    }
    catch(...)
    {
        std::cout << "C::C() exiting with exception\n";
    }
    ~C() { std::cout << "C destroyed\n"; }
};
int main () try
{
    // creates the A base subobject
    // creates the a1 member of B
    // fails to create the a2 member of B
    // unwinding destroys the a1 member of B
    // unwinding destroys the A base subobject
    C c;
}
catch (const std::exception& e)
{
    std::cout << "main() failed to create C with: " << e.what();
}

A(0) constructed successfully
A(1) constructed successfully
A(1) destroyed
B::B() exiting with exception
A(0) destroyed
C::C() exiting with exception
main() failed to create C with: error

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también

• copy elision
• try bloque
• manejador
• noexcept especificador
• Manejo de excepciones