Vous êtes sur la page 1sur 2

ALGORITHMIQUE ET LANGAGE C – L1S2–MPI TD 6 – GROUPE D1

ROSELINE DESCOUT-RENIER JEUDI 13 MARS 2014

Objectifs de la séance :
• Déclaration de fonctions ;
• Différence entre entier et pointeur sur entier / valeur pointée et adresse de la valeur ;
• Passage des paramètres par valeur ou par adresse.

Exercices étudiés pendant la séance : 1 – 2 TD5.

Exercice 1 :
Dans ce code, des noms identiques sont utilisés dans différents morceaux de code pour désigner des grandeurs
différentes.
Exemple : dans le main, y désigne un entier (int y). Dans la déclaration des fonctions titi et tata, il désigne un
pointeur sur entier (int * y).
Réécrivons donc le code avec des noms différents pour chaque variable : les lettres a, b,... et x, y, z désigneront des
entiers, les lettres p, q, r désigneront des pointeurs sur entier.
1 #include <stdio.h>
2
3 int titi(int a, int * p) {
4 *p += a;
5 a += *p;
6 return (a);
7 }
8
9 void tata(int b, int * q, int * r) {
10 b = titi(*q, r);
11 *r += b + *r;
12 }
13
14 int main(void) {
15 int x = 1, y = 2, z = 3;
16 printf("x = %d, y = %d, z = %d.\n", x, y, z);
17 int * q = &y;
18 int * r = &z;
19
20 tata(x, q, r);
21 printf("x = %d, y = %d, z = %d.\n", x, y, z);
22
23 return 0;
24 }

Ligne 15 : On déclare et on affecte les valeurs aux entiers x, y et z.


Ligne 16 : x = 1, y = 2, z = 3.
Lignes 17 et 18 : Je donne des noms aux pointeurs qui contiennent les adresses de y et z pour ne pas les confondre
avec les variables y et z elles-mêmes.
Ligne 20 : Entrée dans la fonction tata.
1. D’après la déclaration de cette fonction, tata prend trois paramètres.
• Le premier paramètre étant passé par valeur, la fonction en fait une copie et travaille sur cette copie.
L’original ne doit donc en principe pas changer.
• Le deuxième et le troisième paramètres sont passés par adresse. C’est donc l’espace mémoire visé par le
pointeur qui va être modifié par la fonction. Les modifications ainsi effectuées persisteront en sortie de
fonction.
2. La fonction tata ne renvoie aucune valeur.
3. Application du code contenu dans tata :
b = titi(*q, r); // on commence par s’intéresser au comportement de la fonction titi avant d’affecter la valeur à b
Entrée dans la fonction titi.
a. D’après la déclaration de cette fonction, titi prend deux paramètres.
• Le premier paramètre est passé par valeur : la fonction en fait une copie et travaille sur cette copie.
L’original ne doit pas changer en sortie de fonction.
• Le deuxième paramètre étant passé par adresse, c’est l’espace mémoire visé par le pointeur qui va être
modifié par la fonction. Les modifications ainsi effectuées persisteront en sortie de fonction.
b. titi prend comme paramètres *q = y et r = &z.
c. titi renvoie une valeur entière.
d. Application du code contenu dans titi :
*p += a; // z = z + y = 3 + 2 = 5
a += *p; // y = y + z = 2 + 5 = 7
return (a); // retourner la valeur 7 en fin de fonction
e. Valeurs des paramètres en sortie de titi :
• Le premier paramètre*q = y est passé par valeur, donc y doit retrouver sa valeur avant application de titi,
soit y = 2.
• Le deuxième paramètre r est passé par adresse, donc la fonction titi a modifié la valeur pointée, soit z = 5.

b = titi(*q, r); // ici, b est le premier paramètre de la fonction, soit ici une copie de x.
Ainsi, x prend la valeur de sortie de la fonction titi, soit x = 7.
*r += b + *r; // z += x + z soit z = z + x + z = 5 + 7 + 5 = 17

4. Valeurs des paramètres en sortie de tata :


• Le premier paramètre x est passé par valeur, donc x doit retrouver sa valeur d’avant l’appel de tata,
soit x = 1.
• Les deuxième et troisième paramètres y et z sont passés par adresse, donc les modifications effectuées sur
ces valeurs sont conservées après la sortie de la fonction tata : y = 2, z = 17.

Ligne 21 : x = 1, y = 2, z = 17.

Exercice 2 :
1. tutu (int i, int j) paramètres 1 et 2 passés par valeur
tata (int i, int * j) paramètre 1 passé par valeur, paramètre 2 passé par adresse
toto (int * i, int j) paramètre 1 passé par adresse, paramètre 2 passé par valeur

2.
int i = 2, j = 4 ;
i = tutu(tutu(i, j), j) ;
→ tutu(2, 4) ; = 36
tutu(36, 4) ; = 1600
en sortie de tutu, les paramètres devraient retrouver leur valeur initiale
respective, soit i = 2, j = 4
i = tutu(tutu(i, j), j) ; Or on affecte le résultat du deuxième tutu à la variable i, donc i = 1600 après
cette ligne.
printf() ; i = 1600, j = 4.

int i = 2, j = 1 ;
toto (&i, j) ;
→ tata (i, &j) ;
→ i = tutu(2, 1) ; i=9
j = tutu(9, 1) ; j = 100
en sortie de tata, i est inchangé, j change, soit i = 1, j = 100.
i=j; i = 100.
en sortie de toto, i change, j est inchangé par rapport à l’entrée dans toto, soit
i = 100, j = 1.
printf() ; i = 100, j = 1.