Dans la première partie de cette série de didacticiels en cours, nous avons brièvement abordé les fonctions, y compris leur déclaration et leur corps. Ce dont nous n'avions pas parlé à l'époque, c'était les multiples façons dont les fonctions sont appelées. Ici, dans ce tutoriel, nous allons aborder rapidement les moyens qui existent.
En langage C, vous pouvez appeler une fonction de deux manières :appel par valeur et appel par pointeur ou adresse. Discutons de ces deux concepts avec quelques exemples faciles à comprendre.
Disons que vous voulez écrire un programme qui échange deux valeurs. Voici comment procéder :
#include <stdio.h>
int main()
{
int a=0, b=0, c=0;
printf("Enter two integer values\n");
scanf("%d %d",&a,&b);
printf("Entered values are: %d and %d", a,b);
c = a;
a = b;
b = c;
printf("\nSwapped values are: %d and %d", a,b);
return 0;
}
Voici la sortie de ce code avec les valeurs saisies comme 5 et 9 :
Enter two integer values
5 9
Entered values are: 5 and 9
Swapped values are: 9 and 5
Maintenant, supposons que l'exigence soit d'avoir une fonction séparée - disons 'swap' - qui effectue tout le travail lié à l'échange et peut être appelée chaque fois que le programmeur veut échanger deux valeurs. Voici le code qui fait cela :
#include <stdio.h>
void swap (int val1, int val2)
{
int temp = 0;
temp = val1;
val1 = val2;
val2 = temp;
printf("\nSwapped values are: %d and %d", val1,val2);
}
int main()
{
int a=0, b=0;
printf("Enter two integer values\n");
scanf("%d %d",&a,&b);
printf("Entered values are: %d and %d", a,b);
swap(a,b);
return 0;
}
Alors voilà. Une fonction distincte nommée 'swap' a été créée qui reçoit deux valeurs (entrées à l'origine par l'utilisateur et capturées dans la fonction 'main') en tant qu'arguments, puis les échange et imprime la sortie.
La façon dont 'swap' a été appelé ici est connue sous le nom de 'call by value'. La raison étant que lorsque l'appel est effectué, seules les valeurs détenues par 'a' et 'b' sont transmises à la fonction 'swap' en tant qu'arguments. Ces valeurs sont reçues par les arguments 'val1' et 'val2', et ce sont ces variables sur lesquelles le processus d'échange est effectué.
Cela signifie que les variables 'a' et 'b' de la fonction 'main' continuent de conserver les valeurs d'origine même après l'exécution de l'opération d'échange. Mais que se passe-t-il si l'exigence est d'avoir les valeurs de 'a' et 'b' échangées après avoir appelé la fonction 'swap' ? Eh bien, c'est là que la méthode "appel par pointeur/adresse" entre en jeu.
Donc, fondamentalement, ce que nous faisons ici, c'est que nous passons l'adresse des variables (comme 'a' et 'b' dans notre cas) comme arguments. La fonction appelée ("swap" dans ce cas) est équipée pour recevoir des adresses en arguments, puis le processus d'échange est effectué sur les valeurs conservées à ces adresses, ce qui signifie en fait les valeurs des variables d'origine ("a" et "b" ici ) être échangé.
Maintenant, dans le paragraphe précédent, nous avons dit que la fonction "est équipée pour recevoir des adresses en arguments". Eh bien, par "équipé", nous entendons qu'il a un type spécial d'arguments qui peuvent recevoir des adresses. Ces arguments sont des variables de type 'pointeur'. Nous discuterons des "pointeurs" en détail dans un prochain didacticiel, mais pour l'instant, gardez simplement à l'esprit que les variables de pointeur stockent les adresses mémoire sous forme de valeurs.
Voici comment un pointeur vers un entier est déclaré/défini :
int *x;
Donc, fondamentalement, x est une variable de pointeur qui peut être utilisée pour stocker l'adresse mémoire d'une variable entière. Supposons que 'i' soit une variable entière, alors voici comment vous pouvez faire en sorte que 'x' stocke l'adresse de 'i' :
x = &i;
Et chaque fois que vous voulez accéder à la valeur de 'i' à 'x', vous écrivez '*x'. Par exemple, voici comment changer la valeur de "i" en, disons, 10 :
*x = 10;
Donc, avec tout cela à l'esprit, voici comment vous pouvez appeler 'swap' en utilisant la méthode d'appel par adresse ou pointeur :
#include <stdio.h>
void swap (int *val1, int *val2)
{
int temp = 0;
temp = *val1;
*val1 = *val2;
*val2 = temp;
}
int main()
{
int a=0, b=0, c=0;
printf("Enter two integer values\n");
scanf("%d %d",&a,&b);
printf("Entered values are: %d and %d", a,b);
swap(&a,&b);
printf("\nSwapped values are: %d and %d", a,b);
return 0;
}
Donc cette fois, au lieu de passer les valeurs de 'a' et 'b' comme arguments, nous avons passé les adresses de ces variables. Dans la fonction 'swap', les adresses sont reçues dans deux variables de pointeur ('val1' et 'val2'). Et en utilisant les deux variables de pointeur, la logique échange directement les valeurs de 'a' et 'b'.
Voici le résultat :
Enter two integer values
6 8
Entered values are: 6 and 8
Swapped values are: 8 and 6
Cet article devrait vous avoir donné au moins une idée de base de ce que sont les méthodes d'appel de fonction "appel par valeur" et "appel par adresse/pointeur", et quand elles peuvent être utilisées. Essayez les exemples que nous avons répertoriés ici et faites-nous savoir dans les commentaires ci-dessous si vous avez des doutes ou des questions.