Chapitre 3 Les Pointeurs

Chapitre 3 :
Les Pointeurs
Zied Trifa
trifa.zied@gmail.com
Plan du chapitre
1) Notion de pointeur
2) Pointeurs et tableaux
3) Pointeurs et chaînes de caractères
4) Allocation dynamique de la mémoire
2
Problème : Je veux écrire une fonction qui renvoie deux valeurs. «

Impossible » me direz-vous ! En effet, on ne peut renvoyer qu'une
valeur par fonction :
int fonction () void fonction ()
{ {
return valeur;
} }
Mais envoyer deux valeurs à la fois … c’est impossible. On ne peut

pas faire deux return. (Par définition, une fonction retourne une
seule valeur).
3
• Exercice : Supposons que je veuille écrire une fonction à laquelle on envoie un
nombre de minutes. Celle-ci renverrait le nombre d'heures et minutes
correspondantes :
– 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.
#include <stdio.h>
void decoupeMinutes(int heures, int minutes) /* déclaration de la fonction */
{
heures = minutes / 60;
minutes = minutes % 60;
} Résultat :
int main() /* programme principal */ 0 heures et 90 minutes
{
int heures = 0, minutes = 90;
decoupeMinutes(heures, minutes); /* appel de la fonction */
printf (”%d heures et %d minutes”, heures, minutes);
return 0;
}
4
• Explication :
• En fait, quand vous « envoyez » 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 ! C'est simplement une copie !
• Votre fonction decoupeMinutes fait son job. À l'intérieur de decoupeMinutes, les variables
heures et minutes ont les bonnes valeurs : 1 et 30.
• Mais ensuite, la fonction s'arrête lorsqu'on arrive à l'accolade fermante.
• Comme vous avez appris dans les chapitres précédents, toutes les variables créées dans une
fonction sont détruites à la fin de cette fonction.
• Vos copies de heures et de minutes sont donc supprimées. On retourne ensuite à la fonction
main, dans laquelle vos variables heures et minutes valent toujours 0 et 90. C'est un échec !
5
• Adresse et valeur :
• Quand vous créez une variable age de type int par exemple, en tapant ça :
• int age =10;
• Votre programme demande au système d'exploitation la permission d'utiliser un peu de
mémoire. Ce dernier répond en indiquant à quelle adresse en mémoire il vous laisse le droit
d'inscrire votre nombre.
• Revenons à notre variable age. La valeur 10 a été inscrite quelque part en mémoire, disons
par exemple à l'adresse n° 4655.
• On sait donc comment récupérer la valeur de la variable :

• printf("La variable age vaut : %d", age); Résultat : La variable age vaut : 10
• Pour afficher l'adresse de la variable

• printf("L'adresse de la variable age est : %p", &age); Résultat : 0023FF74
• Donc :
– age : désigne la valeur de la variable ;
– &age : désigne l'adresse de la variable.
6
• Utiliser des pointeurs :
• Maintenant, nous allons apprendre à créer des variables faites pour contenir des adresses : ce
sont justement ce qu'on appelle des pointeurs.
• Pour créer une variable de type pointeur, on doit rajouter le symbole * devant le nom de la
variable.
– int *monPointeur;
• Il est important d'initialiser dès le début ses variables, en leur donnant la valeur 0 par
exemple. C'est encore plus important de le faire avec les pointeurs !
– int *monPointeur = null;
• la valeur du pointeur est faite pour contenir une adresse. L'adresse… d'une autre variable.
– int age = 10;
– int *pointeurSurAge = &age;
7
• Utiliser des pointeurs :
• Essayons de voir ce que contient le pointeur à l'aide d'un printf :
• Comment faire pour demander à avoir la valeur de la variable se trouvant à l'adresse indiquée
dans pointeurSurAge ? Il faut placer le symbole * devant le nom du pointeur
8
Exemple 1 :
Soit A une variable contenant la valeur 10, B une variable contenant la valeur 50 et P un
pointeur non initialisé :
Après les instructions :

P = &A; /* P pointe sur A*
B = *P; /* Le contenu de A (référencé par *P) est affecté à B */
*P = 20 /* Le contenu de A (référencé par *P) est mis à 20 *
Exemple 2 :
Soit P = &x; les instructions suivantes sont équivalentes :
y=*P+1 à y=x+1
*P=*P+1 à x=x+1
(*P)++ à x++
9
TD N°3 --- Exercice 1 - Enoncé
Écrire un programme se servant de la fonction triplePointeur afin de multiplier par 3 la
valeur d’un nombre.
10
TD N°3 --- Exercice 1 - Solution
#include <stdio.h>
void triplePointeur(int *pointureSurNombre) /* déclaration de la fonction */

{
*pointureSurNombre *=3; /* On multiplie par 3 la valeur de nombre */
}
int main() /* programme principal */
{
int nombre =5;
triplePointeur(&nombre); /* On envoie l’adresse de nombre à la fonction*/
printf (”%d ”, nombre);
return 0;
}
11
Supposons que je veuille écrire une fonction à laquelle on envoie un nombre de
minutes. Celle-ci 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.
12
#include <stdio.h>
void decoupeMinutes(int *heures, int *minutes) /* déclaration de la fonction */
{
*heures = *minutes / 60;
*minutes = *minutes % 60;
}
int main() /* programme principal */
{
int heures = 0, minutes = 90;
decoupeMinutes(&heures, &minutes); /* appel de la fonction */
printf (”%d heures et %d minutes”, heures, minutes);
return 0;
}
13
• L’importance des pointeurs en C :
• En C, les pointeurs jouent un rôle primordial dans la définition de fonctions.
• Les pointeurs sont le seul moyen de changer le contenu de variables déclarées dans d'autres
fonctions.
• Ainsi le traitement de tableaux et de chaînes de caractères dans des fonctions serait

impossible sans l'utilisation de pointeurs.
14
Exemple :
En déclarant un tableau A de type int et un pointeur P sur int :
int A [10];
int *P;
L’instruction P = A; est équivalente à P = &A[0];
A désigne l’adresse de A[0]

A+i désigne l’adresse de A[i]
*(A+i) désigne le contenu de A[i]
P pointe sur l’élément A[0]

P+i pointe sur l’élément A[i]
*(P+i) désigne le contenu de A[i]
15
Soit le programme suivant :
#include<stdio.h>
int main ()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS [10];
int i, j; /* indices courants dans T et POS */
for (j=0; i=0; i<10; i++)
if (T[i] > 0)
{
POS[j] = T[i];
j++;
}
return 0;
}
Remplacer systématiquement la notation T[i] par *(T+i).

16
#include<stdio.h>
int main ()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS [10];
int i, j; /* indices courants dans T et POS */
for (j=0; i=0; i<10; i++)
if (*(T+i)> 0)
{
*(POS+i) = *(T+i);
j++;
}
return 0;
}
17
Ecrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier
et qui ajoute les éléments de B à la fin de A.
Utiliser le formalisme pointeur à chaque fois que cela est possible.
18
TD N°3 --- Exercice 4 – Solution (1/3)
#include<stdio.h>
int main ()
{ /* déclaration */
int A[100], B[50]; /* tableaux */
int n, m; /* dimensions des tableaux */
int i; /* indice courant */
/* saisie des données */
Do
{
printf("Taille du tableau A (N<=50) =");
scanf("%d", &n);
} while (n<0 || n>50);
for(i=0; i<n; i++)

{
printf("Elément n° %d :", i+1);
scanf("%d", &A[i]); /* scanf("%d", A+i) */
}
19
Do
{
printf("Taille du tableau B (N<=50) =");
scanf("%d", &m);
} while (m<0 || m>50);
for(i=0; i<m; i++)

{
printf("Elément n° %d :\n", i+1);
scanf("%d", &B[i]); /* scanf("%d", B+i) */
}
/* Affichage des tableaux */
for(i=0; i<n; i++)
printf("%d :\n", *(A+i)); /* printf("%d :", A[i]); */
for(i=0; i<m; i++)

printf("%d :\n", *(B+i)); /* printf("%d :", B[i]); */
20
/* Copie de B à la fin de A */
for(i=0; i<m; i++)
*(A+n+i) = *(B+i);
/* Nouvelle dimension de A */
n += m;
/* Edition du résultat */
printf("Tableau résultat A : \n");
for(i=0; i<n; i++)
printf("%d :\n", *(A+i));
return 0;
}
21
Écrire un programme qui permet de remplir un tableau d’entiers de dimension N (tel
que N≤50) et d’afficher les nombres impairs.
NB : Le programme doit comporter au minimum 3 fonctions.
22
#include<stdio.h>
int TailleTableau() /* fonction qui retourne la taille du tableau */
{
int Taille;
Do
{
printf("Taille du tableau (N<=50) =");
scanf("%d", &Taille);
} while (Taille<0 || Taille>50);
return Taille;
}
void Remplissage(int Taille, int *TAB) /* fonction remplissage du tableau */
{
int i;
for(i=0; i<Taille; i++)
{
printf("Elément n° %d :", i+1);
scanf("%d", &TAB[i]);
}
} 23
void Affichage(int Taille, int TAB[])
{
int i;
for(i=0;i<Taille;i++)
{
if(TAB[i] % 2 !=0)
printf("% d ", TAB[i]);
}
}
int main()
{
int N;
int T[50];
N=TailleTableau();
Remplissage(N,&T);
Affichage(N,T);
return 0;
}
24
Ecrire un programme qui lit un entier X et un tableau A du type int au clavier et élimine
toutes les occurrences de X dans A en tassant les éléments restants. Le programme
utilisera les pointeurs P1 et P2 pour parcourir le tableau.
25
#include <stdio.h>
int main()
{ /* Déclarations */
int A[50]; /* tableau donné */
int N; /* dimension du tableau */
int X; /* valeur à éliminer */
int *P1, *P2; /* pointeurs d'aide */
/* Saisie des données */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (P1=A; P1<A+N; P1++)
{
printf("Elément %d : ", P1-A); scanf("%d", P1);
}
printf("Introduire l'élément X à éliminer du tableau : ");
scanf("%d", &X );
26
/* Affichage du tableau */
for (P1=A; P1<A+N; P1++)
printf("%d \n ", *P1);
/* Effacer toutes les occurrences de X et comprimer : */
/* Copier tous les éléments de P1 vers P2 et augmenter */
/* P2 pour tous les éléments différents de X. */
for (P1=P2=A; P1<A+N; P1++)
{ *P2 = *P1;
if (*P2 != X) P2++;
}
/* Nouvelle dimension de A */
N = P2-A;
/* Edition du résultat */
for (P1=A; P1<A+N; P1++)
printf("%d \n", *P1);
return 0;
}
27
• un pointeur sur char peut pointer sur un caractère isolé ou sur les
éléments d'un tableau de caractères.
• Un pointeur sur char peut en plus contenir l'adresse d'une chaîne de
caractères constante et il peut même être initialisé avec une telle
adresse.
Exemple 1 :
char *c; c = "Ceci est une chaîne de caractères constante";
28
• Il existe une différence importante entre les deux déclarations :
– char A[] = ‘’Bonjour !’’; /* tableau */
– char *B = ‘’Bonjour !’’; /* un pointeur */
• A est un tableau qui a exactement la grandeur pour contenir la chaîne

de caractères et la terminaison \0. Les caractères peuvent être changés,
amis le nom A va toujours pointer sur la même adresse en mémoire.
• B est un pointeur qui est initialisé de façon à ce qu’il pointe sur une
chaîne de caractères constante stockée quelque part en mémoire. Le
pointeur peut être modifié et pointer sur autre chose. La chaîne peut
être lue, copiée ou affichée, mais pas modifiée.
29
• Conclusions :
– Utilisons des tableaux de caractères pour déclarer les chaînes de caractères que
nous voulons modifier.
– Utilisons des pointeurs sur char pour manipuler des chaînes de caractères
constantes (dont le contenu ne change pas).
– Utilisons de préférence des pointeurs pour effectuer les manipulations à

l'intérieur des tableaux de caractères.
30
Exemple (1/2) :
Reprenons l'exemple de la fonction strcpy, qui copie la chaîne CH2 vers CH1. Les
deux chaînes sont les arguments de la fonction et elles sont déclarées comme pointeurs
sur char. La première version de strcpy est écrite entièrement à l'aide du formalisme
tableau:
void strcpy(char *CH1, char *CH2)
{
int I=0;
while ((CH1[I]=CH2[I]) != '\0')
I++;
}
nous pourrions remplacer simplement la notation tableau[I] par *(tableau + I),
ce qui conduirait au programme:
{
int I=0;
while ((*(CH1+I)=*(CH2+I)) != '\0')
I++;
}
31
Exemple (2/2) :
Un 'véritable' avantage se laisse gagner en calculant directement avec les pointeurs CH1
et CH2 :
{ while ((*CH1=*CH2) != '\0')
{
CH1++;
CH2++;
}
}
un vrai professionnel en C escaladerait les 'simplifications' jusqu'à obtenir :
{
while (*CH1++ = *CH2++)
;
}
32
Ecrire un programme qui lit une chaîne de caractères CH et détermine la longueur de la
chaîne à l'aide d'un pointeur P.
Le programme n'utilisera pas de variables numériques.
33
TD N°3 --- Exercice 7 – Solution
#include <stdio.h>
int main()
char CH[101]; /* chaîne donnée */
char *P; /* pointeur d'aide */
printf("Entrez une ligne de texte (max.100 caractères) :\n");
gets(CH);
/* Placer P à la fin de la chaîne */
for (P=CH; *P; P++) ;
/* Affichage du résultat */
printf("La chaîne \"%s\" est formée de %d caractères.\n", CH, P-CH);
return 0;
}
34
Ecrire un programme qui lit un caractère C et une chaîne de caractères CH au clavier.
Ensuite toutes les occurrences de C dans CH seront éliminées. Le reste des caractères
dans CH sera tassé à l'aide d'un pointeur et de la fonction strcpy.
35
#include <stdio.h>
#include <string.h>
int main()
char C; /* lettre à éliminer */
char *P; /* pointeur d'aide dans CH */
gets(CH);
printf("Entrez le caractère à éliminer (suivi de Enter) :\n");
C=getchar();
36
/* Comprimer la chaîne à l'aide de strcpy */
P=CH;
while (*P)
{
if (*P==C)
strcpy(P, P+1);
else P++;
}
/* Affichage du résultat */
printf("Chaîne résultat : \"%s\"\n", CH);
return 0;
}
37
Ecrire un programme qui lit une chaîne de caractères CH et détermine le nombre de
mots contenus dans la chaîne. Utiliser un pointeur P, une variable logique, la fonction
isspace et une variable numérique N qui contiendra le nombre des mots.
38
#include <stdio.h>
#include <ctype.h>
int main()
char *P; /* pointeur d'aide */
int N; /* nombre des mots */
int DANS_MOT; /* indicateur logique: vrai si P pointe à l'intérieur un mot */
gets(CH);
39
/* Compter les mots */
N=0;
DANS_MOT=0;
for (P=CH; *P; P++)
if (isspace(*P))
DANS_MOT=0;
else if (!DANS_MOT)
{
DANS_MOT=1;
N++;
}
/* Affichage du résultat (pour perfectionnistes) */
printf("La chaîne \"%s\" \n est formée de %d mot%c.\n", CH, N, (N==1)?' ':'s');
return 0;
}
40
• Problème : Souvent, nous devons travailler avec des données dont

nous ne pouvons pas prévoir le nombre et la grandeur lors de la
programmation.
• Ce serait alors un gaspillage de réserver toujours l'espace maximal
prévisible. Il nous faut donc un moyen de gérer la mémoire lors de
l'exécution du programme.
Exemple : Nous voulons lire 10 phrases au clavier et mémoriser les phrases en utilisant
un tableau de pointeurs sur char. Nous déclarons ce tableau de pointeurs par:
char *TEXTE[10];
Problème :
Pour les 10 pointeurs, nous avons besoin de 10*p octets. Ce nombre est connu dès le
départ et les octets sont réservés automatiquement. Il nous est cependant impossible de
prévoir à l'avance le nombre d'octets à réserver pour les phrases elles-mêmes qui seront
introduites lors de l'exécution du programme ...
41
• Solution : Allocation dynamique
• La réservation de la mémoire pour les 10 phrases peut donc seulement
se faire pendant l'exécution du programme. Nous parlons dans ce cas
de l'allocation dynamique de la mémoire.
La fonction « malloc » retourne un pointeur de type char * pointant vers un objet
de taille nombre_octets octets.
Pour initialiser des pointeurs vers des objets qui ne sont pas de type char, il faut
convertir le type de la sortie de la fonction malloc à l'aide d'un cast.
L'argument nombre-octets est souvent donné à l'aide de la fonction sizeof ( )
qui renvoie le nombre d'octets utilisés pour stocker un objet.
#include <stdio.h>
#include <stdlib.h>
void main()
{ int i = 3;
int *p;
p = (int*) malloc (sizeof (int));
*p = i;
printf ("*p = %d\n",*p);
} 42
• NB : Allocation dynamique
• Lorsqu'on n'a plus besoin de l'espace-mémoire alloué dynamiquement
(c'est-à-dire quand on n'utilise plus le pointeur p), il faut libérer cette
place en mémoire.
• Ceci se fait à l'aide de l'instruction free qui a pour syntaxe:
– free (nom-du-pointeur);
43
Exemple 1 :
#include <stdio.h>
#include <stdlib.h>
void main()
{
char *p;
p = (char *) malloc (50);
strcpy (p, "ISAEG")
printf ("*p = %s\n",*p);
free (p);
}
44
Exemple 2 :
#include <stdio.h>
#include <stdlib.h>
void main()
{
int *p, i, s;
p = (int *) malloc (sizeof (int)*20);
for(i=0; i<20; i++)
scanf("%d", &p[i]); /* scanf("%d", p+i); */
for(i=0, s=0; i<20; i++)
s += *(p+i);
printf ( »La somme des 20 entiers = %d\n", s);

free (p);
}
45
Ecrire une fonction qui fait la somme de deux vecteurs d’entier.
Exemple :
V1 : 3 4 2 5 6
V2 : 12 2 14 2 2
V3 : 15 6 16 7 8
46
Solution 1 :
void somme1 (int *v1, int *v2, int *v3, int taille)
{
int i;
for(i=0; i<taille; i++)
*(v3+i) = *(v1+i) + *(v2+i);
}
Solution 2 :
int * somme2 (int *v1, int *v2, int taille)
{
int i;
static int v3 [200];
*(v3+i) = *(v1+i) + *(v2+i);
return v3;
}
47
Solution 3 :
int * somme2 (int *v1, int *v2, int taille)
{
int i, *v3;
v3 = (int *) malloc (sizeof(int)*taille);
*(v3+i) = *(v1+i) + *(v2+i);
return v3;
}
48

Chapitre 3 Les Pointeurs

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 3 Les Pointeurs

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 3 Les Pointeurs

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 3 :

Problème : Je veux écrire une fonction qui renvoie deux valeurs. «

Mais envoyer deux valeurs à la fois … c’est impossible. On ne peut

• Mais ensuite, la fonction s'arrête lorsqu'on arrive à l'accolade fermante.

• On sait donc comment récupérer la valeur de la variable :

• Pour afficher l'adresse de la variable

Après les instructions :

void triplePointeur(int *pointureSurNombre) /* déclaration de la fonction */

• Ainsi le traitement de tableaux et de chaînes de caractères dans des fonctions serait

A désigne l’adresse de A[0]

P pointe sur l’élément A[0]

Remplacer systématiquement la notation T[i] par *(T+i).

for(i=0; i<n; i++)

for(i=0; i<m; i++)

for(i=0; i<m; i++)

NB : Le programme doit comporter au minimum 3 fonctions.

• A est un tableau qui a exactement la grandeur pour contenir la chaîne

– Utilisons de préférence des pointeurs pour effectuer les manipulations à

• Problème : Souvent, nous devons travailler avec des données dont

printf ( »La somme des 20 entiers = %d\n", s);

Vous aimerez peut-être aussi

void triplePointeur(int pointureSurNombre) / déclaration de la fonction */