Memory allocation mechanism for C++ function parameters

C The memory allocation mechanism of function parameters determines how parameters are stored during the call: Pass by value: Parameter copies are passed, and function modifications do not affect the original variables. Pass by reference: The parameter variable address is passed, and the function modification is reflected in the original variable. Passing by constant reference: Similar to passing by reference, but functions are prohibited from modifying reference variables.

C Memory allocation mechanism of function parameters

In C, the memory allocation mechanism of function parameters is crucial, because it determines the parameters in the function call How to store and use during. Understanding the different memory allocation mechanisms allows you to write more efficient and maintainable code.

Pass by value

In pass by value, a copy of the parameter is created and passed to the function. This means that any modifications inside the function will not affect the caller's original variables.

void foo(int x) {
  x++; // 修改函数内的副本
}

int main() {
  int y = 5;
  foo(y); // 传递 y 的副本
  cout << y; // 输出仍然是 5，因为 y 的原始变量未修改
}

Pass by reference

In pass by reference, the address of the parameter variable is passed to the function. This means that any modifications within the function will be reflected in the caller's original variables.

void foo(int& x) {
  x++; // 修改函数内引用的原始变量
}

int main() {
  int y = 5;
  foo(y); // 传递 y 的引用
  cout << y; // 输出为 6，因为 y 的原始变量已修改
}

Constant reference passing

Constant reference is similar to passing by reference, but it ensures that any modifications to the reference variable within the function are invalid.

void foo(const int& x) {
  // 尝试修改函数内引用的原始变量，但编译器会报错
  // x++;
}

int main() {
  int y = 5;
  foo(y); // 传递 y 的常量引用
  cout << y; // 输出仍然是 5，因为 y 的原始变量未修改
}

Practical case: Array sorting

Consider a function that needs to sort an array. If you use pass-by-value, the function receives a copy of the array, and any modifications to the copy will not affect the original array. On the other hand, if you use pass-by-reference, the function can modify the original array and return the sorted result.

// 按值传递
void sortArray_byValue(int arr[], int size) {
  // 创建数组副本并对其进行排序
  int arr_copy[size];
  for (int i = 0; i < size; i++) {
    arr_copy[i] = arr[i];
  }
  std::sort(arr_copy, arr_copy + size);
}

// 按引用传递
void sortArray_byReference(int arr[], int size) {
  // 直接对原始数组进行排序
  std::sort(arr, arr + size);
}

int main() {
  int arr[] = {5, 2, 8, 3, 1};
  int size = sizeof(arr) / sizeof(arr[0]);

  // 使用按值传递排序
  sortArray_byValue(arr, size);
  for (int i = 0; i < size; i++) {
    cout << arr[i] << " "; // 输出无序数组
  }
  cout << endl;

  // 使用按引用传递排序
  sortArray_byReference(arr, size);
  for (int i = 0; i < size; i++) {
    cout << arr[i] << " "; // 输出已排序的数组
  }
}

The above is the detailed content of Memory allocation mechanism for C++ function parameters. For more information, please follow other related articles on the PHP Chinese website!