How to encapsulate exceptions in C++ function exception handling?

C Exception encapsulation enhances the readability and maintainability of the code and can separate error information from processing logic. Error information can be encapsulated by defining an exception class that inherits from std::exception. Use throw to throw exceptions and try-catch to catch exceptions. In the actual case, the function that reads the file uses the exception class to encapsulate the error of failure to open the file. When calling this function, the exception can be caught and the error message can be printed.

Exception encapsulation in C function exception handling

In C functions, exception encapsulation can improve the readability and Maintainability. By encapsulating exceptions, you can separate error information from processing logic, creating clearer, easier-to-understand code.

Definition of exception class

First, we need to define an exception class to encapsulate error information. This class should inherit from the standard library exception class std::exception. For example:

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

This exception class defines a constructor that accepts a string parameter as the exception message.

Exception throwing in a function

Throwing an exception in a function is simple. You can use the throw keyword followed by the exception object:

void myFunction() {
  if (someCondition) {
    throw MyException("发生了一些错误！");
  }
}

Exception catching in the function

To catch exceptions, you can use try and catch blocks:

int main() {
  try {
    myFunction();
  }
  catch (MyException& e) {
    std::cout << "错误：" << e.what() << std::endl;
  }
}

Practical example

Consider a function that reads a file and counts the total number of lines in the file:

int countLines(const std::string& filepath) {
  std::ifstream ifs(filepath);
  if (!ifs.is_open()) {
    throw MyException("无法打开文件！");
  }

  int count = 0;
  std::string line;
  while (std::getline(ifs, line)) {
    ++count;
  }
  return count;
}

In this function, we use the MyException class to encapsulate the error message of file opening failure. When calling this function, we can catch the exception and print the error message:

int main() {
  try {
    int lineCount = countLines("inputFile.txt");
    std::cout << "文件共 " << lineCount << " 行" << std::endl;
  }
  catch (MyException& e) {
    std::cout << "错误：" << e.what() << std::endl;
  }
}

The above is the detailed content of How to encapsulate exceptions in C++ function exception handling?. For more information, please follow other related articles on the PHP Chinese website!