Detailed explanation of C++ member functions: error handling and exception mechanism of object methods

The error handling mechanisms in C member functions include error codes, assertions and exception mechanisms. The error code directly returns the error value; the assertion checks the assumption and throws an exception if it is not true; the exception captures serious errors and handles them through try-catch blocks. In a practical case, the push_back() function of the Vector class throws a std::bad_alloc exception when the capacity is insufficient. Users can catch and handle the exception through try-catch.

Detailed explanation of C member functions: error handling and exception mechanism of object methods

The object methods (member functions) in C are useful for handling complex business logic and errors Conditions are crucial. This article will deeply explore the use of error handling and exception mechanisms in member functions, and provide practical cases to illustrate.

Error handling mechanism

Error code

The most direct error handling method is to use error code. Error codes can be integers or custom enumeration values ​​that represent specific error conditions. In a member function, you can return an error code by setting the errno variable:

int MyFunction() {
  if (... /* 发生错误 */) {
    errno = EINVAL; // 设置错误码为无效参数
    return -1; // 返回错误指示符
  }
  // ... 其它代码
}

Assertion

Assertions are used to check assumptions in the program. If the condition does not hold, an exception is thrown (discussed later). In member functions, you can use the assert() macro to implement assertions:

void MyOtherFunction() {
  assert(ptr != nullptr); // 检查指针是否为 nullptr
  // ... 其它代码
}

Exception mechanism

Exceptions are a powerful mechanism for handling serious error conditions. Exceptions can transfer execution from the location where the error occurred to a specified location. In C, the syntax for exceptions is as follows:

try {
  // 可能发生异常的代码
} catch (exceptionType1& e) {
  // 处理 exceptionType1 类型异常
} catch (exceptionType2& e) {
  // 处理 exceptionType2 类型异常
} catch (...) {
  // 处理所有类型异常
}

Throw an exception

In a member function, you can throw an exception by using the throw keyword. Exceptions can be std::exception and its subclasses in the standard library, or they can be custom exception types:

void MyThrowingFunction() {
  if (... /* 发生严重错误 */) {
    throw std::runtime_error("严重错误！");
  }
  // ... 其它代码
}

Catching exceptions

can be passed in member functions Catch the exception in the try-catch block. The captured exception object can be passed by reference to the catch clause:

void MyCatchingFunction() {
  try {
    MyThrowingFunction();
  } catch (std::runtime_error& e) {
    // 处理 std::runtime_error 类型的异常
  } catch (...) {
    // 处理所有类型异常
  }
}

Practical case

Suppose there is a Vector class, which contains a member Functionpush_back(), this function adds elements to the end of the vector. If the number of elements added to the vector exceeds the preallocated capacity, the push_back() function should throw a std::bad_alloc exception.

class Vector {
public:
  void push_back(int element) {
    try {
      // 尝试添加元素
      // 如果容量不足，会抛出 std::bad_alloc 异常
      elements.push_back(element);
    } catch (std::bad_alloc& e) {
      // 捕获并重新抛出 std::bad_alloc 异常
      throw;
    }
  }

private:
  std::vector<int> elements; // 使用标准库的 std::vector 作为底层存储
};

When using the Vector class, you can capture the exception thrown by the push_back() function as follows:

int main() {
  Vector v;
  try {
    // 尝试向向量添加过多元素，导致容量不足
    for (int i = 0; i < 1000000; i++) {
      v.push_back(i);
    }
  } catch (std::bad_alloc& e) {
    // 捕获 std::bad_alloc 异常并处理
    std::cout << "错误：容量不足！" << std::endl;
    return 1;
  }
  return 0;
}

The above is the detailed content of Detailed explanation of C++ member functions: error handling and exception mechanism of object methods. For more information, please follow other related articles on the PHP Chinese website!