[Análisis en profundidad de C ++] 46. Manejo de excepciones en C ++ (Parte 1)

1 concepto anormal

Pueden producirse excepciones durante la ejecución de un programa. La diferencia entre excepciones y errores es que las excepciones son ramas de ejecución predecibles mientras el programa se está ejecutando. Los errores son errores en el programa y no se espera que se ejecuten. Aquí hay algunas excepciones y errores comunes.

Anormal

• Dividir por 0 en tiempo de ejecución
• El archivo externo a abrir no existe
• Acceso de matriz fuera de límites

Insecto

• Usar puntero salvaje
• La matriz de almacenamiento dinámico no se libera después de su uso
• La ordenación por selección no puede manejar matrices de longitud 0

2 Excepciones en C ++

C ++ tiene elementos de sintaxis incorporados para el manejo de excepciones try ... catch ...

• La instrucción try maneja la lógica de código normal, y la instrucción catch maneja excepciones
• La excepción en la instrucción try es manejada por la instrucción catch correspondiente

C ++ lanza información de excepción a través de la instrucción throw

Los ejemplos son los siguientes:

La excepción lanzada por el lanzamiento en división será atrapada por try ... catch ...

La excepción lanzada por throw debe ser manejada por catch. La función actual puede manejar la excepción, y el programa continúa ejecutándose. Si la función actual no puede manejar la excepción, la función deja de ejecutarse y regresa. Las excepciones no controladas propagarán la pila de llamadas de función hasta que se manejen; de lo contrario, el programa se detendrá.

Experimento de programación: un estudio preliminar del manejo de excepciones de C ++

// 46-1.cpp
#include <iostream>
#include <string>
using namespace std;
double divide(double a, double b)
{
    const double delta = 0.000000000000001;
    double ret = 0;
    if ( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        throw 0;
    }
    return ret;
}
int main(int argc, char *argv[])
{
    try
    {
        double r = divide(1, 0);
        cout << "r = " << r << endl;
    }
    catch(...)
    {
        cout << "Divide by zero..." << endl;
    }
    return 0;
}

El programa primero ejecuta el código en el intento. El lanzamiento en la función de división produce una excepción. No hay captura en la función. La excepción es devuelta a la función principal y atrapada por el captura.

Compilar y ejecutar:

$ g++ 46-1.cpp -o 46-1
$ ./46-1
Divide by zero...

3 prueba ... captura ... detalle

3.1 Un intento y captura múltiple

La misma declaración de prueba puede mantenerse al día con múltiples declaraciones de captura.

• La declaración catch se puede definir como el tipo de excepción manejada específicamente, y diferentes tipos de excepciones son manejados por diferentes declaraciones catch
• Se puede lanzar cualquier tipo de excepción en la declaración de prueba
• catch (...) se usa para manejar todo tipo de excepciones
• Cualquier tipo de excepción solo puede capturarse una vez

catch (...) debe colocarse al final, estrictamente emparejado de arriba a abajo, incluido el atributo const.

Experimento de programación: coincidencia de tipo anormal

// 46-2.cpp
#include<iostream>
using namespace std;
void  Demo1()
{
    try
    {
        throw 'c';
    }
    catch(char c)
    {
        cout << "catch(char c)" << endl;
    }
    catch(short c)
    {
        cout << "catch(short c)" << endl;
    }
    catch(double c)
    {
        cout << "catch(double c)" << endl;
    }
    catch(...)
    {
        cout << "catch(...)" << endl;
    }
}

void Demo2()
{
    throw "error";
}
int main()
{
    Demo1();
    try
    {
        Demo2();
    }
    catch(char* s)
    {
        cout << "catch(char* s)" << endl;
    }
    catch(const char* cs)
    {
        cout << "catch(const char* cs)" << endl;
    }
    catch(string ss)
    {
        cout << "catch(string ss)" << endl;
    }
	return 0;
}

La excepción en la función Demo1 es detectada por la captura en la función. Hay cuatro capturas que capturan char, short, double y todos los demás tipos.

La excepción en Demo2 se devuelve a la función principal antes de ser detectada. El manejo de la excepción debe coincidir estrictamente, incluido el atributo const. El "error" de la excepción lanzada es detectado por catch (const char * cs). Para ser atrapado por catch (string ss), arroje string ("error");

$ g++ 46-2.cpp -o  46-2
$ ./46-2
catch(char c)
catch(const char* cs)

3.2 try ... catch se utiliza para la segmentación

• intente ... catch se usa para separar el código normal y el código anormal

El siguiente código es correcto

3.3 Especifique el tipo de excepción que se puede lanzar

• Para mejorar la legibilidad del código, puede especificar directamente el tipo de excepción que puede producirse durante la declaración y definición de la función

El siguiente código indica que el tipo de excepción que puede lanzar la función es int

Experimento de programación: intente ... capturar código dividido, lanzar especificar tipo de excepción

// 46-1.cpp
#include<iostream>
using namespace std;

int func(int i, int j) throw(int, char)		// 指定可以抛出int和char异常
{
    if (0 < j && j < 10)
    {
        return i + j;
    }
    else
    {
        throw '0';
    }
}

void test(int i) try				// try…catch 用于分割正常代码与异常代码
{
    cout << "func(i, i) = " << func(i, i) << endl;
}
catch (int i)
{
    cout << "Exception: " << i << endl;
}
catch (...)
{
    cout << "Exception..." << endl;
}

int main(int argc, char* argv[])
{
    test(4);
    test(10);
    return 0;
}

Compilar y ejecutar:

func(i, i) = 8
Exception...

4 Resumen

1. try ... catch ... es una instrucción especial para el manejo de excepciones en C ++
2. la instrucción try maneja la lógica del código normal, la instrucción catch maneja la lógica del código de excepción
3. El mismo intento puede coincidir con múltiples sentencias catch
4. El manejo de excepciones debe ser estrictamente emparejado y no realizado Cualquier tipo de conversión