C++ Function Exception Advanced: Customized Error Handling

Exception handling in C can be enhanced with custom exception classes that provide specific error messages, contextual information, and perform custom actions based on the error type. Define an exception class inherited from std::exception to provide specific error information. Use the throw keyword to throw a custom exception. Use dynamic_cast in a try-catch block to convert the caught exception to a custom exception type. In the actual case, the open_file function throws a FileNotFoundException exception. Catching and handling the exception can provide a more specific error message.

C Function Exception Advanced: Customized Error Handling

Exception handling is an important part of handling errors and exceptions in modern programming languages mechanism. In C, exceptions are typically caught and handled using try-catch blocks. However, standard exception types (such as std::exception) provide only limited information, which can make debugging and error handling difficult.

Custom exception classes

To create more informative and actionable exceptions, you can define your own exception class. Benefits of this include:

• Provide specific error messages
• Contain additional contextual information (such as line numbers)
• Perform custom actions based on the error type

To define an exception class, just create a class that inherits from std::exception:

class MyException : public std::exception {
public:
    explicit MyException(const std::string& message) : message(message) {}
    const char* what() const noexcept override { return message.c_str(); }
private:
    std::string message;
};

Use the exception type

When using custom exception classes, you can throw them via the throw keyword:

throw MyException("Error occurred during file operation");

In a try-catch block, you can use dynamic_cast Convert the captured exception to a custom exception type:

try {
    // 代码可能引发异常
} catch (std::exception& e) {
    std::cerr << "Standard exception: " << e.what() << std::endl;
} catch (MyException& e) {
    std::cerr << "MyException: " << e.what() << std::endl;
}

Practical case

Assume there is a function open_file, use to open a file. If the file does not exist or cannot be opened, it will throw a FileNotFoundException exception:

class FileNotFoundException : public std::exception {
public:
    explicit FileNotFoundException(const std::string& filename) : filename(filename) {}
    const char* what() const noexcept override { return ("File not found: " + filename).c_str(); }
private:
    std::string filename;
};

std::ifstream open_file(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        throw FileNotFoundException(filename);
    }
    return file;
}

When calling the open_file function, you can use try-catch block to catch and handle FileNotFoundException:

try {
    std::ifstream file = open_file("myfile.txt");
    // 使用文件
} catch (FileNotFoundException& e) {
    std::cerr << "File not found: " << e.what() << std::endl;
} catch (std::exception& e) {
    std::cerr << "Other error: " << e.what() << std::endl;
}

This way you can provide a more specific error message to aid debugging and error handling.

The above is the detailed content of C++ Function Exception Advanced: Customized Error Handling. For more information, please follow other related articles on the PHP Chinese website!