try block

Una excepción lanzada en un bloque try puede ser manejada por un controlador asociado.

Sintaxis

Bloque try ordinario

Un bloque try ordinario es una sentencia .

Si se lanza una excepción desde su compound-statement , la excepción será comparada con los handlers en su handler-seq :

void f()
{
    throw 1;     // NO manejado por el manejador de abajo
    try
    {
        throw 2; // manejado por el manejador asociado
    }
    catch (...)
    {
        // maneja la excepción 2
    }
    throw 3;     // NO manejado por el manejador de arriba
}

Bloque try de función

Un bloque de función try es un tipo especial de cuerpo de función .

Si se lanza una excepción desde su compound-statement o desde su ctor-initializer (si existe), la excepción será comparada con los handlers en su handler-seq :

int f(bool cond)
{
    if (cond)
        throw 1;
    return 0;
}
struct X
{
    int mem;
    X() try : mem(f(true)) {}
    catch (...)
    {
        // maneja la excepción 1
    }
    X(int) try
    {
        throw 2;
    }
    catch (...)
    {
        // maneja la excepción 2
    }
};

Las excepciones lanzadas en destructores de objetos con duración de almacenamiento estático o en constructores de objetos asociados con variables no de bloque con duración de almacenamiento estático no son capturadas por un bloque try de función en la main función .

Salir del final de la sentencia-compuesta de un manejador de un bloque try de función es equivalente a salir del final de la sentencia - compuesta de ese bloque try de función, a menos que la función sea un constructor o destructor (ver más abajo).

Constructor y destructor try block

Para una clase C , si el cuerpo de la función de su definición de constructor o destructor es un bloque de función try , y se lanza una excepción durante la inicialización o destrucción, respectivamente, de los subobjetos de C , la excepción también será comparada con los manejadores en la secuencia-de-manejadores  del bloque de función try :

int f(bool cond = true)
{
    if (cond)
        throw 1;
    return 0;
}
struct X
{
    int mem = f();
    ~X()
    {
        throw 2;
    }
};
struct Y
{
    X mem;
    Y() try {}
    catch (...)
    {
        // maneja la excepción 1
    }
    ~Y() try {}
    catch (...)
    {
        // maneja la excepción 2
    }
};

Hacer referencia a cualquier miembro no estático o clase base de un objeto en el manejador para un bloque try de función de un constructor o destructor para ese objeto resulta en comportamiento indefinido.

Si una return sentencia aparece en un manejador del bloque try de función de un constructor, el programa está mal formado.

La excepción actualmente manejada es relanzada si el control alcanza el final de un manejador del bloque try de función de un constructor o destructor.

Flujo de control

La compound-statement de un bloque try es una declaración de flujo de control limitado :

void f()
{
    goto label;     // error
    try
    {
        goto label; // OK
        label: ;
    }
    catch (...)
    {
        goto label; // error
    }
}

Una sentencia de salto ( goto , break , return , continue ) puede utilizarse para transferir el control fuera de un bloque try (incluyendo sus manejadores). Cuando esto ocurre, cada variable declarada en el bloque try será destruida en el contexto que contiene directamente su declaración:

try
{
    T1 t1;
    try
    {
        T2 t2;
        goto label; // destruir primero t2, luego t1
    }
    catch(...)
    {
        // se ejecuta si se lanza una excepción al destruir t2
    }
}
catch(...)
{
    // se ejecuta si se lanza una excepción al destruir t1
}
label: ;

Palabras clave

try

Informes de defectos

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

Véase también

• Lanzamiento de excepciones
• Manejo de excepciones