Mécanisme d'allocation de mémoire pour les paramètres de fonction C++

Le mécanisme d'allocation de mémoire des paramètres de fonction C++ détermine la manière dont les paramètres sont stockés lors de l'appel : Passage par valeur : les copies des paramètres sont transmises et les modifications de fonction n'affectent pas les variables d'origine. Passer par référence : l'adresse de la variable paramètre est transmise et la modification de la fonction est reflétée dans la variable d'origine. Passage par référence constante : similaire au passage par référence, mais il est interdit aux fonctions de modifier les variables de référence.

Mécanisme d'allocation de mémoire C++ pour les paramètres de fonction

En C++, le mécanisme d'allocation de mémoire pour les paramètres de fonction est crucial car il détermine la manière dont les paramètres sont stockés et utilisés lors des appels de fonction. Comprendre les différents mécanismes d'allocation de mémoire vous permet d'écrire du code plus efficace et plus maintenable.

Pass by value

En pass by value, une copie du paramètre est créée et transmise à la fonction. Cela signifie que toute modification à l'intérieur de la fonction n'affectera pas les variables d'origine de l'appelant.

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

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

Pass by reference

En pass by référence, l'adresse de la variable paramètre est transmise à la fonction. Cela signifie que toute modification au sein de la fonction sera reflétée dans les variables d'origine de l'appelant.

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

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

Passage par référence constante

La référence constante est similaire au passage par référence, mais elle garantit que toute modification de la variable de référence dans la fonction n'est pas valide.

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

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

Cas pratique : Tri d'un tableau

Considérons une fonction qui doit trier un tableau. Si vous utilisez le passage par valeur, la fonction reçoit une copie du tableau et toute modification apportée à la copie n'affectera pas le tableau d'origine. D'un autre côté, si vous utilisez le passage par référence, la fonction peut modifier le tableau d'origine et renvoyer le résultat trié.

// 按值传递
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] << " "; // 输出已排序的数组
  }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!