Solutions to common exception handling problems in C++

Solutions to common exception handling problems in C require specific code examples

Introduction:
When writing C programs, you often encounter program exceptions situations, such as the divisor is 0, array out of bounds, null pointer access, etc. These exceptions can cause the program to crash or produce unpredictable results. In order to enhance the stability and reliability of the program, we need to use an exception handling mechanism to capture and handle these exceptions. This article will introduce common exception handling problems in C, and give corresponding solutions and specific code examples.

1. Exception catching and handling
   In C, exception catching and handling uses the try-catch statement block. The code in try is the monitored code block. If an exception occurs in it, it will jump to catch for processing. The catch can be followed by multiple exception handling code blocks of different types, and each handling code block can handle the corresponding type of exception. If there is no suitable catch block, the exception will continue to be thrown upward until a suitable handling code block is found.

The following is a simple example:

try {
    // 可能发生异常的代码
    throw 1;  // 抛出一个整型异常
} catch (int e) {
    // 处理整型异常
    cout << "捕获到异常：" << e << endl;
}

2. Standard exception classes
   C provides a set of standard exception classes, which all inherit from std ::exception class. We can use these exception classes to handle common exception situations.

The following are some common standard exception classes and their corresponding exception conditions:

• std::bad_alloc: exception class for memory allocation failure, used to handle insufficient memory Case.
• std::bad_cast: Type conversion error exception class, used to handle type conversion failure.
• std::out_of_range: array out-of-bounds exception class, used to handle array access out-of-bounds situations.
• std::overflow_error: Overflow error exception class, used to handle numerical overflow situations.
• std::underflow_error: Underflow error exception class, used to handle numerical underflow situations.

The following is an example of using the std::out_of_range exception class:

try {
    int arr[5] = {1, 2, 3, 4, 5};
    cout << arr[10] << endl;  // 数组访问越界
} catch (std::out_of_range& e) {
    // 处理数组越界异常
    cout << "捕获到数组越界异常：" << e.what() << endl;
}

3. Custom exception class
   In addition to using the standard exception class, we can also customize it Define exception classes to handle specific exception situations. The custom exception class needs to inherit from the std::exception class and override the what() method in it to provide customized exception description information.

The following is an example of a custom exception class:

class MyException : public std::exception {
public:
    MyException(const std::string& message) : m_message(message) {}

    const char* what() const noexcept {
        return m_message.c_str();
    }

private:
    std::string m_message;
};

try {
    throw MyException("这是一个自定义异常");  // 抛出自定义异常
} catch (MyException& e) {
    // 处理自定义异常
    cout << "捕获到自定义异常：" << e.what() << endl;
}

4. Transmission of exceptions
   Sometimes, after catching an exception, we want to pass it to The caller of the previous level. This can be achieved by using throw statement in catch block.

The following is an example of exception delivery:

void doSomething() {
    try {
        // 可能发生异常的代码
        throw std::runtime_error("发生了一个错误");
    } catch (std::exception& e) {
        // 处理异常，并传递给上一级调用者
        cout << "捕获到异常：" << e.what() << endl;
        throw;
    }
}

try {
    doSomething();
} catch (std::exception& e) {
    // 处理传递过来的异常
    cout << "捕获到传递过来的异常：" << e.what() << endl;
}

Conclusion:
Exception handling is an important part of ensuring the stability and reliability of C programs. This article introduces common exception handling problems in C, and gives corresponding solutions and specific code examples. By properly using the exception handling mechanism, we can better respond to abnormal situations that occur in the program and enhance the robustness of the program.

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