Passer des Arguments par Valeur/Pointeur/Référence

C++ offre un avantage unique en permettant une manipulation directe de la mémoire de l'ordinateur, offrant une plus grande flexibilité à nos programmes. La discussion suivante explorera trois méthodes de passage des arguments de fonction d'un point de vue mémoire.

Passage par valeur

Dans la section précédente, nous avons évoqué la portée des variables et établi que les variables créées à l'intérieur d'une fonction ne sont accessibles qu'à l'intérieur de cette fonction. Ce concept reste valable même lors du passage des arguments à une fonction. Les variables déclarées dans la signature de la fonction ont une portée locale; elles sont passées par valeur, ce qui signifie que leurs valeurs sont copiées dans la fonction et stockées dans des variables distinctes (rappelez-vous de notre exemple du livre de bibliothèque pour mieux comprendre).

main


              123456789101112131415161718
            
#include <iostream>

// Function that takes an argument by value
void modifyValue(int num) {
  // Modify the parameter (local copy of the argument)
  num = num * 2;
  std::cout << "Inside function: " << num << std::endl;
}

int main() {
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass 'number' by value
    modifyValue(number);
    // Varibale in the main function remains unchanged
    std::cout << "After function call: " << number << std::endl;
}

Passer par pointeur

Il n'est pas toujours avantageux de passer des arguments par valeur. Premièrement, passer une copie consomme une mémoire supplémentaire. Deuxièmement, il existe des situations où il est nécessaire de modifier la variable à l'intérieur d'une fonction sans recourir à une instruction de retour. Dans de tels cas, utiliser un pointeur pour transmettre la variable est plus approprié.

Passer une variable par pointeur en C++ en tant qu'argument de fonction implique de transmettre l'adresse mémoire de la variable plutôt que sa valeur réelle.
Le passage par pointeur s'effectue en utilisant des pointeurs (l'opérateur *) dans les paramètres de la fonction.

main


              12345678910111213141516171819202122
            
#include <iostream>

// Function that takes an argument using pointer
void modifyValue(int* numPtr)
{
    // Modify the value at the memory address pointed by numPtr
    // '*' is used to extract the value from the address (pointer)
    *numPtr = (*numPtr) * 2;
    std::cout << "Inside function: " << *numPtr << std::endl;
}

int main()
{
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass the address of 'number' using a pointer
    // '&' is used to get an address of the variable
    modifyValue(&number);
    // 'number' in the main function is modified through the pointer
    std::cout << "After function call: " << number << std::endl;
}

Passage par référence

En C++, le passage par référence signifie transmettre directement l'adresse mémoire d'une variable à une fonction, permettant à cette fonction de modifier la valeur de la variable originale sans opérations supplémentaires (comme le déréférencement du pointeur à l'aide de l'opérateur *).

Le passage par référence se fait en utilisant des références (opérateur &) dans les paramètres de fonction. En général, le passage par référence est très similaire au passage par pointeur, mais il y a deux différences importantes:

il n'est pas nécessaire d'utiliser le déréférencement (*) à l'intérieur de la fonction lors du passage par référence pour utiliser la variable (ce qui donne un accès direct à la variable correspondante).
il n'est pas nécessaire d'utiliser l'opérateur "adresse de" (&) pour passer la référence de la variable comme argument de la fonction lors de l'appel (mais il faut toujours utiliser l'opérateur & au lieu de * dans la signature de la fonction).

main


              1234567891011121314151617181920
            
#include <iostream>

// Function that takes an argument by reference
void modifyValue(int& num)
{
    // Modify the parameter directly (no need for dereferencing)
    num = num * 2;
    std::cout << "Inside function: " << num << std::endl;
}

int main()
{
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass 'number' by reference
    modifyValue(number);
    // 'number' in the main function is modified directly through the reference
    std::cout << "After function call: " << number << std::endl;
}

Conclusion

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 2