Vous êtes sur la page 1sur 13

Chapitre 7:

Les Pointeurs

1
Adressage direct et adressage indirect

Les variables en mémoire:


• Une variable est destinée à contenir une valeur du type avec lequel
elle est déclarée.
• Cette valeur se situe à un emplacement spécifique dans la
mémoire interne.
Exemple: int x; /* Réserve un emplacement pour un entier
en mémoire */
x = 10; /* Écrit la valeur 10 dans l'emplacement
réservé.*/

2
Adressage direct et adressage indirect

En C, on dispose de deux modes d’adressage :

Adressage direct: Accès au contenu d’une variable directement par son nom.
int x;
x = 2;

Adressage indirect: - Accès au contenu d’une variable par le biais de son adresse.

- L’adresse de la variable dans ce cas sera stockée dans une variable spéciale
appelée Pointeur. Et on retrouve ainsi le contenu de la variable en passant par
le pointeur .

3
Notion de Pointeur

- Un pointeur est défini comme une variable spéciale qui contient l’adresse d’une
autre variable.
- Si un pointeur P contient l’adresse d’une variable x, on dit que « P pointe sur x »

Déclaration : <type> * nom_pointeur ;

Exemple: int *p; /* Réserve un emplacement pour stocker


une adresse mémoire.*/

4
Notion de Pointeur

Les opérateurs de base:


& <nom_variable> : fournit l’adresse de la variable
* <nom_pointeur> : désigne le contenu de l’adresse référenciée par le pointeur

Int x ;
Int *p;
x = 10;
p = &x; /* Ecrit l'adresse de x dans p .*/

*p = 10; /* le contenu de x est *p .*/

5
Notion de Pointeur

int x = 10 ;
int *p ;

p = &x;

*p = 10
? p pointe sur x

6
Tableaux et Pointeurs
Les tableaux dynamique :
• En déclarant un tableau, on définit automatiquement un pointeur : on définit en
fait l’adresse du premier élément du tableau et on réserve 10 cases pour les
éléments suivant.
int T[10];
• En déclarant un tableau T de type int et un pointeur sur int : on définit en fait
l’adresse du premier élément du tableau sans réserver de cases mémoire
pour le reste des éléments (longueur variable).
int* P;

L’instruction: P = T est équivalente à P=&T[0]


7
Tableaux et Pointeurs

• Si P pointe sur une composante quelconque d’un tableau, alors P+1 pointe sur la
composante suivante.
• Plus généralement:
P+i pointe sur la i-ème composante devant P
P-i pointe sur la i-ème composante derrière P

• Ainsi: P=T; le pointeur pointe sur T[0]


*(P+1) : contenu de T[1]
….
….
*(P+i) : contenu de T[1]
8
Allocation dynamique de la mémoire

• Souvent, nous devons travailler avec des données dont nous ne pouvons pas
prévoir le nombre et la grandeur lors de la programmation d’où le recours à
l’allocation dynamique de la mémoire.

• La réservation de la mémoire peut donc seulement se faire pendant l’exécution du


programme.

9
Allocation dynamique de la mémoire

• La fonction « malloc » (<stdlib.h> )


malloc( <N> ) fournit l'adresse d'un bloc en mémoire de <N> octets libres ou
la valeur zéro (NULL)s'il n'y a pas assez de mémoire

• L'opérateur unaire ‘sizeof ’


sizeof (<type>) fournit la grandeur pour un objet du type <type>

10
Allocation dynamique de la mémoire

int nbr;
int *p;
printf(" Entrez le nombre de valeurs :");
scanf("%d", &nbr);
p = (int *) malloc(nbr*sizeof(int));

11
Allocation dynamique de la mémoire

• La fonction free (<stdlib.h> )


free( <Pointeur> )
libère le bloc de mémoire (déjà alloué) désigné par le <Pointeur>

• Il est conseillé d'affecter la valeur zéro NULL au pointeur immédiatement


après avoir libéré le bloc de mémoire qui y était attaché.

• Si nous ne libérons pas explicitement la mémoire à l'aide free, alors elle est
libérée automatiquement à la fin du programme.

12
Allocation dynamique de la mémoire
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
main()
main() {
{ int i, nbr;
int i; int *p;
int tab[10] ; printf("entrer un nombre: ");
scanf("%d",&nbr);
for(i=0; i<10; i++)
tab[i]=i; p=(int*)malloc(nbr*sizeof(int));
for(i=0; i<10; i++) for(i=0; i<nbr; i++)
printf("%d\n",tab[i]); *(p+i)=i;
} for(i=0; i<nbr; i++)
printf("%d\n",*(p+i));
free(p);
}
13

Vous aimerez peut-être aussi