Apprendre Passage d'Arguments par Valeur/Pointeur/Référence | Spécification des Arguments de Fonction

C++ offre un avantage unique en permettant la manipulation directe de la mémoire de l'ordinateur, ce qui confère une plus grande flexibilité à nos programmes. La discussion suivante explorera trois méthodes de transmission des arguments de fonction du point de vue de la mémoire.

Passage par valeur

Dans la section précédente, nous avons abordé la portée des variables et établi que les variables créées à l'intérieur d'une fonction ne sont accessibles qu'au sein de cette fonction. Ce concept reste valable même lors du passage d'arguments à une fonction. Les variables déclarées dans la signature de la fonction ont une portée locale ; elles sont transmises 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.cpp


              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;
}

Passage par pointeur

Il n'est pas toujours recommandé de passer les arguments par valeur. Premièrement, passer une copie consomme de la mémoire supplémentaire. Deuxièmement, certaines situations nécessitent de modifier la variable à l'intérieur d'une fonction sans utiliser d'instruction de retour. Dans ces cas, il est plus approprié d'utiliser un pointeur pour passer la variable.

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

main.cpp


              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++, passer par référence signifie transmettre directement l'adresse mémoire d'une variable à une fonction, permettant ainsi à la fonction de modifier la valeur de la variable d'origine sans opérations supplémentaires (comme la déréférence d'un pointeur à l'aide de l'opérateur *).

Le passage par référence s'effectue à l'aide de références (opérateur &) dans les paramètres de fonction. De manière générale, le passage par référence est très similaire au passage par pointeur, mais il existe deux différences importantes :

il n'est pas nécessaire d'utiliser la déréférence (*) à l'intérieur de la fonction lors du passage par référence pour utiliser la variable (ce qui permet 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 en tant qu'argument lors de l'appel de la fonction (mais il faut tout de même utiliser l'opérateur & au lieu de * dans la signature de la fonction).

main.cpp


              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

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 5

Glissez pour afficher le menu

Passage par valeur

main.cpp


              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;
}

Passage par pointeur

main.cpp


              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

il n'est pas nécessaire d'utiliser la déréférence (*) à l'intérieur de la fonction lors du passage par référence pour utiliser la variable (ce qui permet 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 en tant qu'argument lors de l'appel de la fonction (mais il faut tout de même utiliser l'opérateur & au lieu de * dans la signature de la fonction).

main.cpp


              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