PROGRAMMATION
C
(PARTIE 2)
Lissir Amani 2025
2 Chapitre 2
Les pointeurs
Chapitre 2: Les pointeurs
3
Introduction (1/2)
Une variable stocke une valeur et on peut
accéder Une variable a un nom et une
valeur.
On accède à sa valeur directement avec
son nom.
Exemple: Si b = 5, alors on peut écrire :
a = b;
Ici,
a prend directement la valeur de b.
C’est Adressage direct
Chapitre 2: Les pointeurs
4
Introduction (2/2)(Adressage indirect)
•Une variable a aussi une adresse en mémoire.
•Un pointeur est une variable spéciale qui stocke
cette adresse.
•On accède à la valeur de la variable en passant
par son adresse.
Exemple : Si p est un pointeur qui stocke
l’adresse de b, on peut écrire :
a = *p;
Ici, a prend la valeur de b via le pointeur p.
Pourquoi utiliser les pointeurs ?
• Permet de manipuler la mémoire directement.
Chapitre 2: Les pointeurs
5
Définition (1/2)
• Un pointeur est une variable spéciale qui peut contenir l’adresse
d’une autre variable.
• Chaque pointeur est limité à un type de données(int,float,char..)
• Si un pointeur P contient l’adresse d’une variable A, on dit que P
pointe sur A.
Un pointeur fait référence à la variable qu'il
stocke.
Chapitre 2: Les pointeurs
6
Définition (2/2)
Un pointeur constant a une adresse fixe qui ne
change pas.
Exemple : Les noms de tableaux sont des
pointeurs constants.
Ils représentent l’adresse du premier élément
du tableau.
Variables et adresses :
int x ;
&x adresse de x dans la mémoire en Hexadécimal.
int tab[10] ;
tab adresse du premier élément du tableau (&tab[0])
Chapitre 2: Les pointeurs
7
Variable ~ Pointeur
Les pointeurs et les noms de variables
permettent tous deux d'accéder à un endroit
en mémoire.
•Un pointeur peut changer d'adresse, c'est-à-
dire qu'il peut pointer vers différents endroits
en mémoire.
•Un nom de variable est lié à une seule
adresse et ne change pas.
En résumé : un pointeur peut "bouger" d'un
endroit à l'autre, mais le nom d'une variable
reste toujours associé au même emplacement.
Chapitre 2: Les pointeurs
8
Définition de variables pointeurs
Syntaxe :
< type-données> * < nom-
pointeur> ;
Exemple :
int * pi ; la variable "pi" est un pointeur vers
une donnée de type int.
char * pc ; pc un pointeur vers un "char".
Peut contenir l’adresse d’une donnée de type
"char".
pc à le type "char*"
Chapitre 2: Les pointeurs
9
Définition de variables pointeurs
Initialisation vide :
Le symbole NULL permet d’initialiser un pointeur qui ne
pointe sur rien. Cette valeur NULL peut être affectée à tout
pointeur quel que soit le type.
Le symbole NULL est défini dans la librairie stdlib.h.
Exemple:
int *pNombre=NULL;
Dès qu’on déclare un pointeur, il est préférable de l’initialiser à NULL.
Chapitre 2: Les pointeurs
10
Définition de variables pointeurs
Initialisation :
int x ; // variable ordinaire
int * pi ; // variable pointeur
float *pf ;
float y ;
L’opérateur unaire & appliqué à une
variable permet d’obtenir l’adresse de cette
variable.
Soit : pi = &x ; pi est un pointeur vers int,
initialisé avec l’adresse de la variable x ;
Affichage : printf ( "%x",&x) ; // Hexadécimal
Chapitre 2: Les pointeurs
11
Accès indirect aux variables
L'accès indirect aux variables avec des
pointeurs en C se fait en utilisant l'opérateur
d'indirection *. Cela permet d'accéder à la
valeur stockée à l'adresse mémoire pointée par
un pointeur.
Exemple 1:
1. x=3;
2. pi=&x ;
3. y =*pi ; y=x;
Chapitre 2: Les pointeurs
12
Exemple 2:
int *pNombre;
int n=20;
pNombre=&n; /* pNombre pointe sur l’entier n
qui contient la valeur 20 */
printf (ˈˈ %d ˈˈ, *pNombre); /*affiche la valeur 20 */
*pNombre=40;
printf(ˈˈ %d ˈˈ, *pNombre); /*affiche la valeur 40 */
printf(ˈˈ %d ˈˈ, n); /*affiche la valeur 40 */
Chapitre 2: Les pointeurs
13
Les tableaux et les pointeurs
-Chaque opération avec des indices de tableaux peut être aussi exprimée à l’aide de
pointeurs.
- Comme nous l’avons déjà vu dans le cours, le nom d’un tableau représente
l’adresse du premier élément du tableau.
&tableau[0] et tableau représentent l’adresse du premier élément du tableau
.
- Le nom d’un tableau est un pointeur constant sur le premier élément du tableau.
int A[10];
int * P;
P = A; /*est équivalente à P = &A[0]*/
Chapitre 2: Les pointeurs
14
Les tableaux et les pointeurs
A : adresse de A[0]
A+i : adresse de A[i]
*(A+i) : Le contenue de A[i]
P : Pointe sur A[0]
A+i : Pointe sur A[i]
*(A+i) : Le contenue de A[i]
Chapitre 2: Les pointeurs
15
Arithmétique des pointeurs – Sizeof()
8
Chapitre 2: Les pointeurs
16
Arithmétique des pointeurs – Incrémentation
1004
Chapitre 2: Les pointeurs
17
Arithmétique des pointeurs – Décrémentation
1004
Chapitre 2: Les pointeurs
18
Arithmétique des pointeurs – Addition
Chapitre 2: Les pointeurs
19
Arithmétique des pointeurs – Soustraction
Chapitre 2: Les pointeurs
20
Arithmétique des pointeurs – Comparaison
Chapitre 2: Les pointeurs
21
Exercice 1 :
Soit P un pointeur qui pointe Sur un
tableau A :
Int A[] = {12,23,34,45,56,67,78,89,90};
Int *P;
P=A;
Quelles valeurs ou adresses fournissent
ces expressions :
Chapitre 2: Les pointeurs
22
Instruction Résultat
++P
*(P+3)
P-&A[4]
--P;
A+6
P == &A[4]
P >= A;
Chapitre 2: Les pointeurs
23
Exercice 2 : A l’aide des pointeurs , écrivez un programme qui
calcule la somme , le produit , la différence et la division de
deux nombres réels .
Chapitre 2: Les pointeurs
24
Chapitre 2: Les pointeurs
25
Les pointeurs et les chaînes de caractères
•Les mêmes règles des pointeurs et tableaux s'appliquent
aux chaînes de caractères.
•Une chaîne de caractères est un tableau de char terminé
par \0.
•On peut stocker l'adresse d'une chaîne constante dans un
pointeur char*.
Exemple:
char* p_ch = "ProgrammationC"; // p_ch pointe vers une chaîne de caractères.
Chapitre 2: Les pointeurs
26
Les pointeurs et les chaînes de caractères
• Le compilateur place la chaîne « ProgrammationC" dans une zone
mémoire de 15 octets, c'est‐à‐dire un tableau de 15 caractères qui contient
les 14 lettres du mot ProgrammationC et le caractère ‘ \0 ‘.
• A l'exécution, l'affectation p_ch = " ProgrammationC " met l'adresse de
cette zone mémoire dans le pointeur p_ch p_ch pointe donc sur le
premier caractère de la chaîne.
Chapitre 2: Les pointeurs
27
Exercice 3: À l’aide des pointeurs, écrivez un programme qui manipule une
chaîne de caractères en effectuant les opérations suivantes :
• Calculer la longueur de la chaîne.
• Convertir tous les caractères en majuscules.
• Inverser la chaîne.
Chapitre 2: Les pointeurs
28
#include <stdio.h>
#include <ctype.h> // Pour la fonction toupper()
// Fonction pour calculer la longueur de la chaîne
// Fonction pour convertir tous les caractères en majuscules
Chapitre 2: Les pointeurs
29
// Fonction pour inverser la chaîne
Chapitre 2: Les pointeurs
30
// Fonction pour inverser la chaîne trace d’éxecution
int main() {
char str[100];
// Saisir une chaîne de caractères
printf("Entrez une chaîne de caractères : ");
fgets(str, sizeof(str), stdin); \\ stdin :endroit où l'utilisateur saisit du texte
//lit la chaîne et inclut le caractère de nouvelle ligne (\n) à la fin de la chaîne
// Le programme supprime ce caractère
str[strcspn(str, "\n")] = '\0';
// Calculer la longueur
int length = longueur_chaine(str);
printf("La longueur de la chaîne est : %d\n", length);
// Convertir en majuscules
convertir_en_majuscule(str);
printf("La chaîne après conversion en majuscules : %s\n", str);
// Inverser la chaîne
inverser_chaine(str);
printf("La chaîne inversée : %s\n", str);
return 0;
}
31
Chapitre 2: Les pointeurs
32
Allocation dynamique de tableaux
Un tableau statique a une dimension bien
définie à l’avance et possède en outre un
nom, a l’aide du quel on peut accéder aux
divers éléments du tableau.
Un tableau dynamique, en revanche, a une
dimension variable et ne possède pas de
nom par lequel aurait accès aux éléments
du tableau. Désormais, on utilise un
pointeur qui pointe vers des données du
type des valeurs saisies.
Fonctions prédéfinies pour la gestion
Chapitre 2: Les pointeurs
33
Allocation de mémoire avec malloc
malloc permet de réserver un espace en mémoire pendant
l'exécution du programme.
Syntaxe :
<pointeur> =malloc (< taille>) ; // taille en octet
Retourne l’adresse du bloc de mémoire réservé rangée
dans un pointeur. Et on peut via ce pointeur accéder
au bloc de mémoire alloué.
Exemple :
double * tab ; // Déclaration d'un pointeur pour stocker l'adresse
du bloc alloué
tab = malloc (400) ; // allocation d’un bloc mémoire de
//400 octets et rangement de son
adresse
tab est un tableau de 50 éléments de type double
//dans un pointeur double.
Chapitre 2: Les pointeurs
34
Allocation dynamique de tableaux
Gestion des erreurs :
Si malloc n’arrive pas à réserver le bloc mémoire
souhaité (pas assez d’espace mémoire) elle retourne
le pointeur NULL.
if(tab==NULL) // Vérification de l'échec de
l'allocation
pintf("Allocation demander impossible"); // Message
d'erreur si l'allocation échoue
else
{ for(i=0;i<50;i++) // Si l'allocation a réussi, on
peut utiliser le tableau
Chapitre 2: Les pointeurs
35
Allocation dynamique de tableaux
La taille d'un type de données (comme int)
peut varier selon l'architecture de la machine
(2 ou 4 octets pour int).
Exemple : int occupent 2 ou 4 octets selon
la machine.
Pour résoudre ce problème, on utilise
l'opérateur sizeof qui retourne
tab = malloc(100 la taille
* sizeof(int)); en octets
// Allocation
d'uncorrecte
type. Parenexemple,
fonction pour
de laallouer
taille dedeint
la
mémoire pour 100 éléments int, on écrit :
• Cela garantit que la mémoire
allouée est adaptée, quelle que
Chapitre 2: Les pointeurs
36
Allocation dynamique de tableaux
malloc renvoie un pointeur de type void*, qui
est générique et peut pointer vers n'importe
quel type de données. Cependant, il est
nécessaire de convertir ce pointeur void*
en un pointeur du type spécifique (par
exemple, int* ou double*) pour que le
programme puisse correctement accéder à la
mémoire allouée.
On aura :
tab = (double*) malloc (100 * sizeof (double)) //
Allocation pour un tableau de doubles
Ou
Chapitre 2: Les pointeurs
37
Allocation dynamique de tableaux
Libération de la mémoire avec « free »
Elle
permet de libère l’espace mémoire qui a
été alloué par les fonctions malloc, et realloc
pour éviter les fuites de mémoire.
Syntaxe :
free (<pointeur>) ;
Exemple :
free (tab) ;
Chapitre 2: Les pointeurs
38
Pointeurs et structures
Les structures pouvant être gérées par des
pointeurs. On définit les pointeurs vers des
structures
x et px permettant d’accéder aux champs de la
variable structurée « x »
[Link] ; et [Link] ; \\ Accéder au champ "name" et "num" de la
Chapitre 2: Les pointeurs
39
Pointeurs et structures
Accès aux champs d’une structure pointée :
Syntaxe :
(* < pointeur>).<champ> ;
Peut être remplacé par :
<pointeur><champ> ;
(*px).name pxname ;
Chapitre 2: Les pointeurs
40
Les pointeurs et les fonctions
Passage des paramètres par adresse
(référence)
-En C, return ne permet de retourner qu’une seule valeur.
- Parfois une fonction doit retourner plusieurs résultats en sortie.
-Il n’y a qu’une solution pour retourner plusieurs résultats:
passer en paramètre l’adresse des variables où seront stockés les
résultats.
-Le passage par adresse est aussi utile pour modifier le contenu
des variables déclarées dans d’autres fonctions .
Chapitre 2: Les pointeurs
41
Les pointeurs et les fonctions
Passage des paramètres par adresse
(référence)
Exemple: Une fonction qui retourne le minimum et le maximum de deux entiers a
et b.
Chapitre 2: Les pointeurs
42
Exercice 1 : Allocation dynamique de tableau avec pointeurs
Écrire un programme en C qui :
[Link] à l'utilisateur la taille d'un tableau d'entiers.
[Link] dynamiquement ce tableau avec malloc.
[Link] le tableau avec des valeurs saisies par l'utilisateur en
utilisant un pointeur.
[Link] les valeurs du tableau en utilisant un pointeur.
[Link]ère la mémoire avec free.
Chapitre 2: Les pointeurs
43
Chapitre 2: Les pointeurs
44
1️⃣ Saisie du
taille de la matrice
L'utilisateur entre un nombre (par
exemple, 5), ce qui signifie qu'on
alloue un tableau de 5 cases pour
stocker des entiers.
2️⃣
\\évite les fuites mémoire.
Allocation dynamique de
mémoire
Le programme réserve de la
mémoire pour 5 entiers, comme
3
3️⃣ Remplissage de la matrice réserver 5 chambres dans un
L'utilisateur entre des valeurs (par exemple, 1, 2, 3, 4,hôtel.
5), et ces valeurs sont
stockées dans les cases du tableau.
4️⃣ Affichage des valeurs
Le programme affiche chaque valeur en accédant à chaque case du tableau.
5️⃣ Libération de la mémoire
Une fois les valeurs utilisées, la mémoire est libérée pour pouvoir être réutilisée.
Chapitre 2: Les pointeurs
45
Exercice : Pointeurs et Structures
Écrire un programme en C qui permet :
[Link] définir une structure Etudiant contenant :
•nom (chaîne de caractères de taille 30)
•age (entier)
•moyenne (flottant)
[Link] déclarer une variable e1 de type Etudiant et de saisir ses
informations.
3.D’utiliser un pointeur pour accéder et afficher les champs de e1.
Chapitre 2: Les pointeurs
46
RQ:
✔ Tableaux (char nom[30];) → Pas besoin de &
✔ Variables classiques (int, float...) → Besoin de &
Chapitre 2: Les pointeurs
47
Chapitre 2: Les pointeurs
48
FIN
