Mme.

Jinène Moslah

1
 Un pointeur est une variable particulière, dont la valeur est
l'adresse d'une autre variable.

 Déclaration :
type *pointeur ;
◦ le type est celui de(s) la variable(s) se trouvant à l‟adresse mémoire
stocké dans pointeur
◦ En accédant à cette adresse, on peut accéder indirectement à la
variable et donc la modifier.
◦ Le symbole * est utilisé entre le type et le nom du pointeur

 Exemple : int*p; // déclaration d‟un pointeur sur entier

 Les pointeurs sont nécessaires pour:

◦ effectuer les appels par référence (i.e. écrire des fonctions qui modifient
certains de leurs paramètres)

◦ manipuler des structures de données dynamiques (liste, pile, arbre,…)

◦ allouer dynamiquement de la place mémoire

3
 Exemples de déclarations
 Affectation de l‟adresse d‟une variable :
int i = 10; 5A0F3 10
int*p ; On dit que le pointeur p pointe vers i,
p = &i ; puisque p pointe vers l‟emplacement p i
mémoire où est enregistrée i.

 Affectation de l‟adresse d‟un tableau :

int numero[10] = {1,11, 2, 3, 19, 5, 13, 17, 23,7}; 4A0C3
Int *p ; p
p = numero;
/* p pointe sur la première case 1 11 2 3 19 5 13 17 23 7
de numero  p = &(numero[0]) ; */
numero
 Opérateurs unaires pour manipuler les pointeurs,
& (adresse de) * (contenu)
Exemple 1: int i = 8;
printf("VOICI i: %d\n",i);
printf("VOICI SON ADRESSE EN HEXADECIMAL: %p\n", &i);

Exemple 2:
nom_de_Pointeur = &nom_de_variable;
void main(void) p c
{ 0x91A2
0x1132 'a'
char c = 'a', d = 'z'; 0x1132
char *p;
d
'z'
0x91A2
p = &c;
printf("%c\n", *p);
p = &d;
printf("%c\n", *p);
} a
z L‟opérateur * (“valeur pointée par”)
Exemple
int*p, x, y;
printf("x\ty\t*p\tp\n");
p = &x; /* p pointe sur x */
x = 10; /* x vaut 10 */
y = *p -1; printf("%d\t%d\t%d\t%d\n" , x, y, *p,p);
*p += 1; printf("%d\t%d\t%d\t%d\n" , x, y, *p,p);
(*p)++; printf("%d\t%d\t%d\t%d\n" , x, y, *p,p);
*p=0; printf("%d\t%d\t%d\t%d\n" , x, y, *p,p);
*p++; *p=20; printf("%d\t%d\t%d\t%d\n" , x, y, *p,p);
#include <stdio.h>
void main() {
int *p, x, y;
p = &x; /* p pointe sur x */
x = 10; /* x vaut 10 */
y = *p - 1; printf(" y= *p - 1 =? = %d\n" , y); y vaut ?
*p += 1; printf(" *p += 1 =? *p = x= ? = %d %d\n" , *p, x); x vaut ?
(*p)++; printf(" (*p)++ =? *p = x= ? = %d %d alors y=%d \n" , *p, x, y);
incrémente aussi de 1 la variable pointée par p, donc x vaut ??.
y vaut 9

*p=0; printf(" *p=0 x=? = %d\n" , x);

comme p pointe sur x, maintenant x vaut ?

*p++; *p=20; printf(" *p++ x=? = %d\n" , x);

} comme p ne pointe plus sur x, x vaut tjr ?
8
  On peut accéder aux éléments par pointeurs en faisant des calculs
d’adresses (addition ou soustraction)

long v[6] = { 1,2,3,4,5,6 };

long *p;
p += 4
p = v; p++
printf("%ld\n", *p);
p++;
p
printf("%ld\n", *p);
p += 4; 1000 1 2 3 4 5 6
v
printf("%ld\n", *p); 1000 1008 1016
1 1004 1012 1020
2
6

9
  T[0] est équivalent à *T
 T[i] est équivalent à *(T + i)
 &T[0] est équivalent à T
short T[8] = { 10, 20, 30, 40, 50, 60, 70, 80 };
short *p = T;

printf("%d\n", T[3]); 40
printf("%d\n", *(T + 3)); 40
printf("%d\n", *(p + 3)); 40
printf("%d\n", p[3]); 40

p T
1000 10 20 30 40 50 60 70 80
1000 1004 1008 1012
1002 1006 1010 1014

10
char * malloc( unsigned taille);
Réserve taille octets, sans initialisation de l'espace. Retourne un pointeur sur une zone de
taille octets.

char * calloc(unsigned nombre, unsigned taille);

réserve nombre éléments de taille octets chacun; l'espace est initialisé à 0.

Exemple: #include<stdlib.h>
int* p;
p = (int *) malloc ( sizeof ( int )); /*en principe sizeof(int)=4 */

Allocation dynamique d‟un tableau

#include<stdlib.h>
int* tab;
tab = (int *) malloc(100 * sizeof ( int ));
void * realloc ( void *block, unsigned taille);
Modifie la taille affectée au bloc de mémoire fourni par un précédent appel à
malloc() ou calloc().

Void free ( void *block);

Libére le bloc mémoire pointé par un précédent appel à malloc(), calloc() ou realloc().

Important :
malloc, calloc, realloc retournent le pointeur NULL (0) si l'espace disponible est
insuffisant.
un test serait donc judicieux
La mémoire dynamique varie en cours
d'exécution, et peut n'être pas suffisante pour
allouer les variables, provoquant le plantage
du programme. Il faut donc tester le retour des
fonctions d'allocation et traiter les erreurs.

L'espace alloué doit être libéré par free(),

dont l'argument est un pointeur réservé
dynamiquement. free(var);
 Déclarez une variable char c puis l‟initialisez à „A‟
 Affichez son adresse.
 Déclarer un pointeur p sur char pour le créer avec la fonction malloc ().
 Ajoutez *p = c ;
 Affichez la valeur du pointeur p, la valeur pointée par p et l‟adresse de
p.
 Libérez p avec free(p) puis afficher la valeur de l‟objet pointé par p et la
valeur de c. Que Remarquez-vous ?
 Réaffichez la valeur du pointeur p, la valeur pointée par p et l‟adresse de
p.
 Ajoutez p = &c ;
 Réaffichez de nouveau la valeur du pointeur p, la valeur pointée par p et
l‟adresse de p.
 Essayez maintenant un free(p). Que se passe-t-il ?