C++ exception handling methods

c Exception handling

We often encounter some abnormal situations when the program is running, for example: divisor when doing division is 0; the user entered a negative number when entering age; when using the new operator to dynamically allocate space, there is not enough space and cannot be allocated; when accessing array elements, the subscript is out of bounds; when opening a file for reading, the file does not exist, etc.

These abnormal situations, if not discovered and handled, are likely to cause the program to crash.

The so-called "processing" can mean giving an error message and then allowing the program to continue executing along an error-free path; it can also mean having to end the program, but doing some necessary work before ending. Such as writing data in memory to files, closing open files, releasing dynamically allocated memory space, etc.

C introduces exception handling mechanism. The basic idea is: when function A finds an exception during execution, it can not handle it, but just "throw an exception" to the caller of A, assumed to be function B.

Throwing an exception without handling it will cause function A to terminate immediately. In this case, function B can choose to catch the exception thrown by A and handle it, or it can choose to ignore it. If ignored, the exception will be thrown to the caller of B, and so on.

If the functions at each level do not handle exceptions, the exception will eventually be thrown to the outermost main function. The main function should handle exceptions. If the main function does not handle the exception, the program will terminate abnormally immediately.

C Basic syntax for exception handling

C Exception handling is implemented through throw statements and try...catch statements. The syntax of the throw statement is as follows:

throw  表达式;

This statement throws an exception. An exception is an expression whose value type can be a primitive type or a class.

try...catch 语句的语法如下：
try {
    语句组
}catch(异常类型) {
  异常处理代码
}...catch(异常类型) {
    异常处理代码
}

There can be multiple catches, but must have at least one .

We might as well call try and the content in {} as a "try block", and call catch and the content in {} as a "catch block"

try... The execution process of the catch statement is: execute the statements in the try block. If no exception is thrown during the execution, then the statements following the last catch block will be executed after the execution, and all statements in the catch block will not be executed; If an exception is thrown during the execution of the try block, then immediately after the exception is thrown, it jumps to the first catch block whose "exception type" matches the thrown exception type for execution (it is said that the exception is "caught" by the catch block "), after execution, jump to the end of the last catch block to continue execution.

For example, the following program:

#include <iostream>
using namespace std;
int main()
{
    double m ,n;
    cin >> m >> n;
    try {
        cout << "before dividing." << endl;
        if( n == 0)
            throw -1; //抛出int类型异常
        else
            cout << m / n << endl;
        cout << "after dividing." << endl;
    }
    catch(double d) {
        cout << "catch(double) " << d <<  endl;
    }
    catch(int e) {
        cout << "catch(int) " << e << endl;
    }
    cout << "finished" << endl;
    return 0;
}

The running result of the program is as follows:

9 6↙
before dividing.
1.5
after dividing.
finished

Explanation that when n is not 0, no exception will be thrown in the try block . Therefore, after the try block is executed normally, the program continues execution beyond all catch blocks, and none of the catch blocks will be executed.

The running result of the program may also be as follows:

9 0↙
before dividing.
catch\(int) -1
finished

When n is 0, an integer exception will be thrown in the try block. After an exception is thrown, the try block stops execution immediately. The integer exception will be caught by the first catch block that matches the type, that is, it will enter the catch(int e) block for execution. After the catch block is executed, the program will continue to execute until it ends normally.

If the exception thrown is not caught by the catch block, for example, change catch(int e) to catch(char e), when the input n is 0, the integer exception thrown will not be If the catch block can catch it, the exception will not be handled, then the program will terminate immediately, and the content after try...catch will not be executed.

The above is the detailed content of C++ exception handling methods. For more information, please follow other related articles on the PHP Chinese website!