Exceptions are handled in C mainly through try, catch and throw. Use try to wrap the code that may cause errors and use catch to catch and process it, such as: 1. It is recommended to catch the standard library exception type by reference to avoid copying; 2. Use throw to throw the standard library exception or custom exception, and the basic type is not recommended; 3. You can create a custom exception class by inheriting std::exception and overwrite the what() method; 4. Exception handling needs to be clearly classified, and use catch with caution to ignore exceptions; 5. The project should decide whether to enable the exception mechanism based on the specifications.

In C, exception handling is mainly achieved through the three keywords try , catch and throw . In short, you can throw an exception in a block of code that may be wrong (using throw ) and then catch and process it where appropriate (wrap the code that may be wrong with try and catch the exception with catch ).

Here are some common practices and precautions in actual operation:

Catch exceptions using try-catch block

When you have a piece of code that may throw an exception, put it in a try block and then follow one or more catch blocks to handle possible errors.

 try {
    // Code that may throw exception throw std::runtime_error("Something went wrong!");
}
catch (const std::runtime_error& e) {
    std::cout << "Caught runtime error: " << e.what() << std::endl;
}
catch (...) {
    std::cout << "Caught an unknown exception." << std::endl;
}

• You can write multiple catch blocks according to different exception types.
• It is recommended to capture by reference (such as const std::exception& ) to avoid unnecessary copies.
• Finally, you can add a catch (...) to prevent unhandled exceptions from causing program crash.

How and timing of throwing exceptions

Use throw to throw exception objects of any type, but it is recommended to use exception classes in the standard library, such as std::invalid_argument , std::out_of_range , std::runtime_error , etc.

 if (index < 0 || index >= size) {
    throw std::out_of_range("Index out of bounds");
}

• Don't throw basic types (such as int or char* ) casually, as this is not easy to maintain and lacks semantics.
• It is a good habit to explain the possible exceptions thrown in the function interface documentation.
• If you don't plan to handle exceptions, don't catch them and ignore them.

Custom exception type

Sometimes the exception types provided by the standard library are not enough, you can inherit std::exception or its subclass to customize the exception:

 class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Custom exception occurred";
    }
};

Then you can throw and catch like this:

 throw MyException();

catch (const MyException& e) {
    std::cout << e.what() << std::endl;
}

• Implementing what() method is the key to return error information.
• More member variables can be added to carry error codes or other context information.

Basically that's it. Exception handling is not omnipotent, and all errors are not suitable for exception handling. Whether the exception mechanism is enabled in C depends on the project specification and compiler settings (for example, some embedded environments turn off exception support by default). However, once you decide to use it, you should pay attention to clear structure and clear classification to avoid abuse.

The above is the detailed content of How to throw and catch exceptions in C ?. For more information, please follow other related articles on the PHP Chinese website!