Les pointeurs

Paternité - Partage des Conditions Initiales à l'Identique : http://creativecommons.org

/licenses/by-sa/4.0/fr/
 Table des
matières
I - Les pointeurs 3

1. Activité ........................................................................................................................................................... 3

2. La mémoire ..................................................................................................................................................... 4

3. Les pointeurs ................................................................................................................................................... 5

3.1. Créer un pointeur ......................................................................................................................................................................... 5
3.2. Utiliser un pointeur ...................................................................................................................................................................... 6

4. Envoyer un pointeur à une fonction ................................................................................................................ 7

4.1. 1ère façon ................................................................................................................................................................................... 8
4.2. 2ème façon .................................................................................................................................................................................. 8
4.3. La fonction scanf ........................................................................................................................................................................ 9

5. La solution correcte du problème ................................................................................................................... 9

6. Applications .................................................................................................................................................. 12
6.1. Application 1 ............................................................................................................................................................................. 12
6.2. Application 2 ............................................................................................................................................................................. 12

7. Pointeurs et tableaux ..................................................................................................................................... 13

7.1. Adressage des composantes d'un tableau .................................................................................................................................... 13
7.2. Application ................................................................................................................................................................................ 14
7.3. Arithmétique des pointeurs ......................................................................................................................................................... 15
7.4. Exercice ..................................................................................................................................................................................... 15
7.5. Passage de tableaux à une fonction ........................................................................................................................................... 17
 Les pointeurs

Les pointeurs
I
1. Activité
Rappel
Une fonction ne peut renvoyer qu'une seule valeur. On ne peut pas faire deux « return ».

Exemple
On veut écrire une fonction à laquelle on envoie un nombre de minutes et elle renverrait le nombre d'heures et
minutes correspondantes.

Exemple :

- si on envoie 45, la fonction renvoie 0 heure et 45 minutes ;

- si on envoie 60, la fonction renvoie 1 heure et 0 minutes ;
- si on envoie 90, la fonction renvoie 1 heure et 30 minutes.

1 #include <stdio.h>
2
3
4 void decoupeMinutes(int heures, int minutes)
5{
6 heures = minutes / 60; // 90 / 60 = 1
7 minutes = minutes % 60; // 90 % 60 = 30
8}
9
10 int main()
11 {
12 int heures = 0, minutes = 90;
13
14 /* On a une variable minutes qui vaut 90.
15 Après appel de la fonction, je veux que ma variable
16 "heures" vaille 1 et que ma variable "minutes" vaille 30 */
17
18 decoupeMinutes(heures, minutes);
19
20 printf("%d heures et %d minutes", heures, minutes);
21
22 return 0;
23 }
24

Le résultat obtenu est :

3
 La mémoire

En fait, quand on envoie une variable à une fonction, une copie de la variable est réalisée. Ainsi, la variable
heures dans la fonction « decoupeMinutes() » n'est pas la même que celle de la fonction « main ».

À l'intérieur de « decoupeMinutes() », les variables heures et minutes ont les bonnes valeurs : 1 et 30.

Mais ensuite, les copies de heures et minutes sont donc supprimées lorsque la fonction s'arrête (toutes les
variables créées dans une fonction sont détruites à la fin de cette fonction).

Dans la fonction main, les variables heures et minutes valent toujours 0 et 90.

2. La mémoire
La figure suivante contient un schéma très simplifié du fonctionnement de la mémoire vive.s

Il faut en gros distinguer deux colonnes :

- les adresses : une adresse est un nombre qui permet à l'ordinateur de se repérer dans la mémoire vive. On
commence à l'adresse 0 (au tout début de la mémoire) et on finit à une adresse qui dépend de la capacité
de la mémoire.
- Les valeurs : à chaque adresse, on peut stocker une valeur (un nombre).

Exemple

1 int age = 10;

Avec cette instruction, le programme demande au système d'exploitation la permission d'utiliser un peu de
mémoire. Le système d'exploitation répond en indiquant à quelle adresse en mémoire il lui laisse le droit
d'inscrire le nombre.

L'instruction suivante permet d'afficher la valeur de la variable age :

1 printf("La valeur de la variable age est %d",age);

Le résultat affiché est :

4
 Les pointeurs

Pour afficher l'adresse de la variable, on doit utiliser le symbole %p dans le printf. En outre, on doit envoyer à
la fonction printf non pas la variable age, mais son adresse. Et pour faire cela, on doit mettre le symbole &
devant la variable age.

1 printf("L'adresse de la variable age est %p",&age);

Le résultat affiché est :

Fondamental
- age : désigne la valeur de la variable ;
- &age : désigne l'adresse de la variable.

3. Les pointeurs
Dans cette section, nous allons apprendre à créer des variables faites pour contenir des adresses : ce sont
justement ce qu'on appelle des pointeurs.

Fondamental
Un pointeur indique l'adresse d'une autre variable en mémoire.

3.1. Créer un pointeur

Pour créer une variable de type pointeur, on doit rajouter le symbole * devant le nom de la variable.

Exemple : Exemple 1

1 int *monPointeur;

Ce code va réserver une case en mémoire comme si vous aviez créé une variable normale. Cependant, et c'est
ce qui change, la valeur du pointeur est faite pour contenir une adresse : L'adresse d'une autre variable.

Exemple : Exemple 2

1 int age = 10;//Créer une variable de type int dont la valeur vaut 10
2 int *pointeurSurAge = &age;//Créer une variable de type pointeur dont la valeur
vaut l'adresse de la variable age
Cet exemple est équivalent à l'exemple suivant :

1 int age = 10;

2 int *pointeurSurAge; // 1) Créer une variable de type pointeur nommée
"pointeurSurAge"
3 pointeurSurAge = &age; // 2) "pointeurSurAge contient l'adresse de la variable
age"

Attention
Il n'y a pas de type « pointeur » comme il y a un type int et un type double par exemples. Au lieu de ça, on
utilise le symbole * avant le type de la variable dont le pointeur va contenir l'adresse.

5
 Exemple

1 double *monPointeur;//créer un pointeur qui pointe sur une variable de type

double.

Remarque
On dit que le pointeur pointeurSurAge pointe sur la variable age.

Exemple
Le pointeur pointeurSurAge contient l'adresse de la variable age. La variable age a été placée à l'adresse
177450 (sa valeur est 10), et le pointeur pointeurSurAge a été placé à l'adresse 3.

3.2. Utiliser un pointeur

Pour demander à avoir la valeur du pointeur (cette valeur est une adresse), il faut utiliser le nom du pointeur.

Exemple

1 int age = 10;

2 int *pointeurSurAge = &age;
3
4 printf("%p", pointeurSurAge);// affiche 177450, équivalente à printf("%p", &age);

Pour demander à avoir la valeur de la variable se trouvant à l'adresse indiquée dans le pointeur, il faut placer le
symbole * devant le nom du pointeur.

6
 Envoyer un pointeur à une fonction

Exemple

1 int age = 10;

2 int *pointeurSurAge = &age;
3
4 printf("%d", *pointeurSurAge);// le programme affiche 10

Exemple

Attention
Attention à ne pas confondre les différentes significations de l'étoile :

- Lorsqu'on déclare un pointeur, l'étoile sert juste à indiquer qu'on veut créer un pointeur.
Exemple : int *pointeurSurAge;
- Lorsqu'on veut la valeur de la variable sur laquelle pointe pointeurSurAge.
Exemple : printf("%d", *pointeurSurAge);

4. Envoyer un pointeur à une fonction

Le gros intérêt des pointeurs est qu'on peut les envoyer à des fonctions pour qu'ils modifient directement une
variable en mémoire. En effet, on les utilise pour faire un passage par variable (par adresse).

Exemple
On veut écrire une fonction triple() qui permet de multiplier la valeur d'un entier pris en paramètre par trois.

7
4.1. 1ère façon

1 #include <stdio.h>
2
3 void triple(int *pointeurSurNombre)
4{
5 *pointeurSurNombre = *pointeurSurNombre * 3; // On multiplie par 3 la valeur
de nombre
6}
7
8 int main()
9{
10 int nombre = 5;
11
12 triple(&nombre); // On envoie l'adresse de nombre à la fonction
13 printf("%d", nombre); // affiche 15
14 //On affiche la variable nombre. La fonction a
directement modifié la valeur de la variable car elle connaissait son adresse
15
16 return 0;
17 }
18

Explication

La fonction triple() prend un paramètre de type int* (c'est-à-dire un pointeur sur int). Voici ce qu'il se passe
dans l'ordre, en partant du début du main :

- une variable nombre est créée dans le main. On lui affecte la valeur 5 ;
- on appelle la fonction triple(). On lui envoie en paramètre l'adresse de notre variable nombre ;
- la fonction triple() reçoit cette adresse dans pointeurSurNombre. À l'intérieur de la fonction triple(), on
a donc un pointeur pointeurSurNombre qui contient l'adresse de la variable nombre ;
- maintenant qu'on a un pointeur sur nombre, on peut modifier directement la variable nombre en
mémoire : il suffit d'utiliser *pointeurSurNombre pour désigner la variable nombre ;
- de retour dans la fonction main, nombre vaut maintenant 15 car la fonction triple() a modifié
directement la valeur de nombre.

Remarque
On peut faire un simple return pour écrire la fonction triple(). Mais l'intérêt, là, c'est que de cette manière, en
utilisant des pointeurs, on peut modifier la valeur de plusieurs variables en mémoire : on peut donc « renvoyer
plusieurs valeurs ».

4.2. 2ème façon

La deuxième façon consiste à écrire le code précédent, en ajoutant un pointeur dans la fonction main.

1 #include <stdio.h>
2
3 void triple(int *pointeurSurNombre)
4{
5 *pointeurSurNombre *= 3;// On multiplie par 3 la valeur de nombre
6}
7

8
 8 int main()
9{
10 int nombre = 5;
11 int *pointeur = &nombre;// pointeur prend l'adresse de nombre
12
13 triple(pointeur);// On envoie pointeur (l'adresse de nombre) à la fonction
14 printf("%d\n", *pointeur);//affiche 15
15 // On affiche la valeur de nombre avec *pointeur
16
17 printf("%d", nombre);//affiche 15 => la valeur de la variable nombre a été
modifiée
18 return 0;
19 }
20

Explication

Ce qui compte, c'est d'envoyer l'adresse de la variable nombre à la fonction. Or, pointeur vaut l'adresse de la
variable nombre. On le fait seulement d'une manière différente en créant un pointeur dans la fonction main.

Remarque
Les deux instructions printf affichent la même chose car *pointeur et nombre désignent la même chose dans
la mémoire.

4.3. La fonction scanf

La fonction scanf travaille avec un pointeur sur la variable à saisir et peut ainsi modifier directement son
contenu.

En effet, cette fonction a pour rôle de lire ce que l'utilisateur a entré au clavier. Pour que la fonction puisse
modifier directement le contenu de votre variable afin d'y placer la valeur tapée au clavier, elle a besoin de
l'adresse de la variable.

Exemple

1 int nombre;
2 scanf("%d", &nombre);

On peut créer un pointeur qu'on envoie à la fonction scanf.

Exemple

1 int nombre;
2 int *pointeur = &nombre;
3 scanf("%d", pointeur);

5. La solution correcte du problème

1ère façon

1 #include <stdio.h>
2

9
 La solution correcte du problème

3 void decoupeMinutes(int *pointeurHeures, int *pointeurMinutes)

4{
5 /* Attention à ne pas oublier de mettre une étoile devant le nom
6 des pointeurs. Comme ça, on peut modifier la valeur des variables */
7 *pointeurHeures = *pointeurMinutes / 60;
8 *pointeurMinutes = *pointeurMinutes % 60;
9}
10
11 int main()
12 {
13 int heures = 0, minutes = 90;
14
15 // On envoie l'adresse de heures et minutes
16 decoupeMinutes(&heures, &minutes);
17
18 // Cette fois, les valeurs ont été modifiées
19 printf("%d heures et %d minutes", heures, minutes);
20
21 return 0;
22 }
23

Le résultat obtenu est :

Explication :

- Les variables heures et minutes sont créées dans la fonction main.

- On envoie à la fonction decoupeMinutes() l'adresse de heures et minutes.
- La fonction decoupeMinutes() récupère ces adresses dans des pointeurs appelés pointeurHeures et
pointeurMinutes. Notez que là on peut les appeler avec des autres noms que heures et minutes.
- La fonction decoupeMinutes() modifie directement les valeurs des variables heures et minutes en
mémoire car elle possède leurs adresses dans des pointeurs.

Attention
Il faut impérativement mettre une étoile devant le nom des pointeurs si on veut modifier la valeur de heures et
de minutes.

2ème façon

1 #include <stdio.h>
2
3 void decoupeMinutes(int *pointeurHeures, int *pointeurMinutes)
4{
5 /* Attention à ne pas oublier de mettre une étoile devant le nom
6 des pointeurs. Comme ça, on peut modifier la valeur des variables */
7 *pointeurHeures = *pointeurMinutes / 60;
8 *pointeurMinutes = *pointeurMinutes % 60;
9}
10
11 int main()
12 {

10
 Applications

13 int heures = 0, minutes = 90;

14 int *pointeurHeures = &heures;
15 int *pointeurMinutes = &minutes;
16
17 // On envoie les pointeurs
18 decoupeMinutes(pointeurHeures, pointeurMinutes);
19
20 // Cette fois, les valeurs ont été modifiées
21 printf("%d heures et %d minutes\n", heures, minutes);
22 //printf("%d heures et %d minutes", *pointeurHeures, *pointeurMinutes);
23
24 return 0;
25 }
26

11
6. Applications
6.1. Application 1

Enoncé

Ecrire une fonction permettant de saisir une variable entière >0.

Solution

1 #include <stdio.h>
2
3 void saisie(int *n)
4{
5 do
6 {
7 printf("Donner un entier >0\n");
8 scanf("%d",n);
9 }
10 while(*n<=0);
11 }
12
13 int main()
14 {
15 int nombre;
16 int *pointeur = &nombre;
17 //scanf("%d",pointeur);
18 //saisie(&nombre);
19 saisie(pointeur);
20 printf("nombre = %d\n",nombre);
21 printf("nombre = %d\n",*pointeur);
22
23 return 0;
24 }
25

6.2. Application 2
Soient les déclarations suivantes :

1 int x = 2, y = 4, a = 3 ;
2 int *p1, *p2 ;
3

donner le contenu des variables x, y et a après exécution des instructions suivantes :

1/ p1 = &x ;

2/ p2 = &y ;

3/ *p1 = (*p2)++ ;

4/ p1 = p2 ;

5/ p2 = &a ;

6/ *p1 -= *p2 ;

12
 Pointeurs et tableaux

7/ ++ *p1 ;

8/ *p2 *= *p1 ;

9/ a = (++ *p1) * (*p2) ;

10/ p1 = &x ;

11/ y = *p2 / *p1;

1 #include <stdio.h>
2
3 int main()
4{
5 int x = 2, y = 4, a = 3 ;//déclarer 3 variables de type int
6 int *p1, *p2 ;//déclarer 2 pointeurs qui peuvent recevoir et manipuler des
adresses des variables de type int
7
8 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 2, y= 4, a = 3
9 p1 = &x ;//p1 pointe sur x
10 p2 = &y ;//p2 pointe sur y
11 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 2, y= 4, a = 3
12 *p1 = (*p2)++ ;//contenu de y (pointé par p2) est affecté à x (pointé par p1)
13 //puis contenu de y (pointé par p2) est incrémenté
14 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 5, a = 3
15 p1 = p2 ;//p1 pointe sur la même variable pointée par p2 => pointent sur y
16 p2 = &a ;//p2 pointe sur a
17 *p1 -= *p2 ;//soustraction le contenu de a (pointé par p2) du contenu de y
(pointé par p1)
18 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 2, a = 3
19 ++ *p1 ;//le contenu de y (pointé par p1) est incrémenté
20 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 3, a = 3
21 *p2 *= *p1 ;//le contenu de a (pointé par p2) est multiplié par le contenu de
y (pointé par p1)
22 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 3, a = 9
23 a = (++ *p1) * (*p2) ;//le contenu de y (pointé par p1 est incrémenté
24 //puis le contenu de a devient le résultat du produit de y
(pointé par p1) et a (pointé par p2)
25 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 4, a = 36
26 p1 = &x ;//p1 pointe sur x
27 y = *p2 / *p1;//le contenu de y devient le résultat de a/y
28 printf("x = %d, y = %d, a = %d\n",x,y,a);//x = 4, y= 9, a = 36
29
30 return 0;
31 }
32

7. Pointeurs et tableaux
Lors de la manipulation des tableaux, chaque opération manipulé avec des indices peut être exprimée à l'aide de
pointeurs.

7.1. Adressage des composantes d'un tableau

- Le nom d'un tableau représente l'adresse de son premier élément.
- Le nom d'un tableau est un pointeur constant sur le premier élément du tableau.

13
 Exemple
Soient les déclarations suivantes :

int v[20], *p ;

- p = v <=> p = &v[0]
- si p pointe sur v[i], alors p+1 pointe sur v[i+1], p+j pointe sur v[i+j] et p-k pointe sur v[i-k].

si on a p=v, alors

*p => contenu de v[0]

*(p+1) => contenu de v[1]

*(p+2) => contenu de v[2]

...

*(p+k) => contenu de v[k]

Remarque
Il existe toujours une grande différence entre un pointeur et le nom d'un tableau :

- un pointeur est une variable. => p = v et p++ ou p-- sont possibles et correctes ;
- le nom d'un tableau est une constante => v = p ou v++ ou v-- sont impossibles et incorrectes ;

7.2. Application
Utiliser la notion de pointeur pour écrire un programme C qui remplit un tableau T de réels avec n réels (taille
max =50) puis l'afficher.

1 #include <stdio.h>
2
3 int main()
4{
5 int n, *pn;
6 float T[50], *p;
7 pn = &n;
8 do
9 {
10 printf("Donner un entier\n");
11 scanf("%d",pn);
12 }
13 while(*pn<=0 || *pn>50);
14
15 for(p=T;p<T+*pn;p++)
16 {
17 printf("Donner un reel\n");
18 scanf("%f",p);
19 }
20
21 printf("Les elements de T sont :\n");
22 for(p=T;p<T+*pn;p++)
23 {
24 printf("%f\n",*p);
25 }

14
 26
27 return 0;
28 }
29

7.3. Arithmétique des pointeurs

7.3.1. Affectation

Soient p et q deux pointeurs sur le même type de données, l'instruction :

p = q fait pointer p sur le même objet pointé par q

Exemple

int *p, *q, a=10, b=15 ;

p = &a ;

q = p ; /* q pointe sur la variable a qui est pointée par p */

7.3.2. Incrémentation et décrémentation des pointeurs

Si p pointe sur l'élément T[i] du tableau T, alors après l'opération :

p++ , p pointe sur T[i+1]

p-- , p pointe sur T[i –1]

p+=n , p pointe sur T[i+n]

p-=n , p pointe sur T[i – n ]

Remarque
L'addition, la soustraction, l'incrémentation et la décrémentation sur les pointeurs doivent être limitées et
définies à l'intérieur du domaine du tableau.

7.3.3. Comparaison des pointeurs

La comparaison de deux pointeurs qui pointent dans le même tableau est équivalente à la comparaison des
indices correspondants et elle peut se faire en utilisant les opérateurs de comparaison : <, >, <=, >=, ==, !=

7.4. Exercice
Soit p un pointeur qui pointe sur un tableau V

1 int V[ ] = {12, 20, 40, 15, 45, 50, 32, 30, 48};
2 int *p ;
3p = V ;

donner le résultat en terme de valeur ou adresse de ces expressions:

*p + 4

*(p+4)

&V[5] - 2

V+3

15
p + (*p – 8)

*(p + *(p+5) – V[8])

Solution

*p + 4 => valeur (16)

*(p+4) => valeur (45)

&V[5] - 2 => adresse (&V[3])

V + 3 => adresse (&V[3])

p + (*p – 8) => adresse (&V[4])

*(p + *(p+5) – V[8]) => valeur (40)

16
7.5. Passage de tableaux à une fonction
7.5.1. Tableau comme paramètre formel (définition)

Syntaxe : 1ère façon

[type] NomFonction (type NomTableau[ ])

Exemple : Définition et appel d'une fonction saisieTab

Définir une fonction saisieTab permettant de remplir un tableau d'entiers (long) :

1 void saisieTab(int n, long t[])

2{
3 int i;
4 for(i=0 ; i<n ; i++)
5 scanf("%ld",&t[i]);
6}

Syntaxe : 2ème façon

[type] NomFonction (type *NomPointeur)

Exemple : Définition et appel d'une fonction saisieTab

Définir une fonction saisieTab permettant de remplir un tableau d'entiers (long) :

1 void saisieTab(int n, long *t)

2{
3 int *p ;
4 for(p=t ; p<t+n ; p++)
5 scanf("%ld", p) ;
6}

Remarque

Il est préférable d'utiliser la 1ère façon parce que la présence des crochets permet au programmeur de bien voir
que c'est un tableau que la fonction prend, et non un simple pointeur. Cela permet d'éviter des confusions.

7.5.2. Tableau comme paramètre effectif (appel)

Soient les déclarations suivantes :

1 int n;
2 long t[20];

Pour appeler la fonction saisieTab, on peut utiliser l'une des méthodes suivantes :

Exemple : 1ère façon

1 saisietab(n, &t[0]);

17
 Exemple : 2ème façon

1 saisietab(n, t);

Exemple : 3ème façon

1 int *p=t;
2 saisietab(n, p);

7.5.3. Application

Enoncé

Ecrire un programme C permettant de remplir un tableau de réels (taille max = 20), l'afficher puis calculer et
afficher la somme de ses éléments.

Utiliser les fonctions suivantes :

- Une fonction saisieNb pour saisir un entier entre 3 et 20

- Une fonction saisieTab pour remplir les n 1ères cases d'un tableau de réels.
- Une fonction calculerSomme pour calculer la somme des éléments du tableau.
- Une fonction affichTab pour l'affichage des éléments du tableau.

Correction

1 #include <stdio.h>
2
3 void saisieNb(int *x)
4{
5 do
6 {
7 printf("Donner un entier entre 3 et 20\n");
8 scanf("%d",x);
9 }
10 while(*x<3 || *x>20);
11 }
12
13 //1ère méthode pour écrire la fonction saisieTab
14 void saisieTab(int n, float t[])
15 {
16 int i;
17 for(i=0 ; i<n ; i++)
18 scanf("%f",&t[i]);
19 }
20
21 //2ème méthode pour écrire la fonction saisieTab
22 /*void saisieTab(int n, float *t)
23 {
24 float *p ;
25 for(p=t ; p<t+n ; p++)
26 scanf("%f", p);
27 }*/
28
29 //1ère méthode pour écrire la fonction calculerSomme
30 float calculerSomme(int n, float t[])

18
 31 {
32 float somme = 0;
33 int i;
34 for(i=0 ; i<n ; i++)
35 somme+=t[i];
36 return somme;
37 }
38
39 //2ème méthode pour écrire la fonction calculerSomme
40 /*float calculerSomme(int n, float *t)
41 {
42 float somme = 0;
43 float *p ;
44 for(p=t ; p<t+n ; p++)
45 somme+=*p;
46 return somme;
47 }*/
48
49 //1ère méthode pour écrire la fonction affichTab
50 void affichTab(int n, float t[])
51 {
52 int i;
53 printf("le contenu du tableau est : \n ") ;
54 for(i=0 ; i<n ; i++)
55 printf("%.2f ", t[i]) ;
56 }
57
58 //2ème méthode pour écrire la fonction affichTab
59 /*void affichTab(int n, float *t)
60 {
61 float *p ;
62 printf("le nouveau contenu du tableau est : \n ") ;
63 for(p=t ; p<t+n ; p++)
64 printf("%.2f ", *p) ;
65 }*/
66
67 int main()
68 {
69 int nb;
70 float U[20],s;
71
72 //saisie de nombre d'éléments
73 saisieNb(&nb);
74
75 //remplir le tableau U
76 //1ère méthode pour remplir le tableau U
77 saisieTab(nb, U);
78 //2ème méthode pour remplir le tableau U
79 //float *p1=U ; saisieTab(nb, p1);
80 //3ème méthode pour remplir le tableau U
81 //saisieTab(nb, &U[0]);
82
83 //afficher le tableau U
84 //1ère méthode pour afficher le tableau U
85 affichTab(nb, U);
86 //2ème méthode pour afficher le tableau U
87 //float *p1=U ; affichTab(nb, p1);
88 //3ème méthode pour afficher le tableau U

19
 89 //affichTab(nb, &U[0]);
90
91 //calculer la somme des éléments du tableau U
92 //1ère méthode pour calculer la somme des éléments du tableau U
93 s = calculerSomme(nb, U);
94 //2ème méthode pour calculer la somme des éléments du tableau U
95 //float *p1=U ; s = calculerSomme(nb, p1);
96 //3ème méthode pour calculer la somme des éléments du tableau U
97 //s = calculerSomme(nb, &U[0]);
98
99 //afficher la somme
100 printf("La somme des elements du tableau = %.2f",s);
101
102 return 0;
103 }
104

20