The relationship between C++ function parameter passing method and exception handling

C Function parameter passing method affects exception handling: value passing: exceptions are not propagated to the calling function. Pass by reference: Exceptions are propagated to the calling function. Pointer passing: The exception is propagated to the calling function, and the pointing variable throws the exception.

C The relationship between function parameter passing method and exception handling

In C, function parameters can be passed by value or reference Or pointer passing in three ways. The specific delivery method chosen will not only affect the performance of the function, but also have an impact on exception handling.

1. Value transfer

Value transfer is the simplest method of transfer. When a parameter is passed by value, the function gets a copy of the parameter value. If the function modifies the value of this copy, the parameter values ​​in the original function will not be affected.

void print_value(int x) {
  x++;  // x是参数值的副本
}

int main() {
  int a = 10;
  print_value(a);
  std::cout << a << std::endl;  // 输出仍然是10
}

• Exception handling association: If a function passes a parameter by value, and the parameter throws an exception, the exception will not be propagated to the calling function.

2. Passing by reference

Passing by reference is similar to passing by value, but the function does not obtain a copy of the parameter value, but a reference to the parameter value. This means that any modification of the parameters by the function will directly affect the parameter values ​​in the original function.

void print_value(int& x) {
  x++;  // x是参数值的引用
}

int main() {
  int a = 10;
  print_value(a);
  std::cout << a << std::endl;  // 输出是11
}

• Exception handling association: If a function passes a parameter by reference, and the parameter throws an exception, the exception will be propagated to the calling function.

3. Pointer passing

Pointer passing is a more flexible parameter passing method. When a parameter is passed as a pointer, the function gets the address of the variable pointed to by the parameter. Functions can indirectly access and modify the value of variables through pointers.

void print_value(int* x) {
  (*x)++;  // 通过指针间接访问并修改变量的值
}

int main() {
  int a = 10;
  print_value(&a);
  std::cout << a << std::endl;  // 输出是11
}

• Exception handling association: If the function passes parameters by pointer, and the pointed variable throws an exception, the exception will be propagated to the calling function.

Practical case:

The following is an example of using function pointer passing and exception handling:

#include <iostream>
#include <exception>

void do_something(int* x) {
  if (*x < 0) {
    throw std::runtime_error("Invalid value");
  }
  *x *= 2;
}

int main() {
  try {
    int a = 5;
    void (*fp)(int*) = &do_something;  // 获取函数指针
    fp(&a);  // 通过函数指针调用函数
    std::cout << a << std::endl;  // 输出是10
  } catch (const std::exception& e) {
    std::cerr << e.what() << std::endl;  // 输出异常消息
  }
  return 0;
}

In this example,do_something The function passes parameters as pointers. If the parameter value is less than 0, the function throws an exception. The calling function calls the do_something function through the function pointer and uses exception handling to catch potential exceptions.

The above is the detailed content of The relationship between C++ function parameter passing method and exception handling. For more information, please follow other related articles on the PHP Chinese website!