Lors du travail avec des pointeurs, nous avons besoin
- d'un opérateur 'adresse de': &
pour obtenir
l'adresse d'une variable.
- d'un opérateur 'contenu de': *
pour accéder au
contenu d'une adresse.
- d'une syntaxe de déclaration
pour pouvoir déclarer un
pointeur.
L'opérateur 'adresse de' : &
&<NomVariable> fournit l'adresse de la variable <NomVariable>
L'opérateur & nous est déjà familier par la fonction scanf, qui a besoin de l'adresse de ses arguments pour pouvoir leur attribuer de nouvelles valeurs.
Exemple
int N;
printf("Entrez un nombre entier : ");
scanf("%d", &N);
Attention !
L'opérateur & peut seulement être appliqué à des objets qui se trouvent dans la mémoire interne, c.-à-d. à des variables et des tableaux. Il ne peut pas être appliqué à des constantes ou des expressions.
Représentation schématique
Soit P un pointeur non initialisé
et A une variable (du même type) contenant la valeur 10 :
Alors l'instruction
P = &A;affecte l'adresse de la variable A à la variable P. En mémoire, A et P se présentent comme dans le graphique à la fin du chapitre 9.1.2. Dans notre représentation schématique, nous pouvons illustrer le fait que 'P pointe sur A' par une flèche:
*<NomPointeur> désigne le contenu de l'adresse référencée par le pointeur <NomPointeur>
Exemple
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; B = *P; *P = 20;- P pointe sur A,
- le contenu de A (référencé par *P) est affecté à B, et
- le contenu de A (référencé par *P) est mis à 20.
Déclaration d'un pointeur
Déclaration d'un pointeur
<Type> *<NomPointeur> déclare un pointeur <NomPointeur> qui peut recevoir des adresses de variables du type <Type>
Une déclaration comme
int *PNUM;peut être interprétée comme suit:
"*PNUM est du type int"
| |
|
ou
|
|
| "PNUM
est un pointeur sur int"
| |
|
ou
|
|
| "PNUM
peut contenir l'adresse d'une variable du type int"
|
Exemple
Le programme complet effectuant les transformations de l'exemple ci-dessus peut se présenter comme suit:
|main()
|
ou
bien
|
|main()
|
| |{
|
|{
| |
| |
/* déclarations */
|
|
|/*
déclarations */
|
| |
short A = 10;
|
|
short A, B, *P;
| |
| |
short B = 50;
|
|
/* traitement */
| |
| |
short *P;
|
|
A = 10;
| |
| |
/* traitement */
|
|
B = 50;
| |
| |
P = &A;
|
|
P = &A;
| |
| |
B = *P;
|
|
B = *P;
| |
| |
*P = 20;
|
|
*P = 20;
| |
| |
return 0;
|
|
return 0;
| |
| |}
|
|}
|
Remarque
Lors de la déclaration d'un pointeur en C, ce pointeur est lié explicitement à un type de données. Ainsi, la variable PNUM déclarée comme pointeur sur int ne peut pas recevoir l'adresse d'une variable d'un autre type que int.
Nous allons voir que la limitation d'un pointeur à un type de variables n'élimine pas seulement un grand nombre de sources d'erreurs très désagréables, mais permet une série d'opérations très pratiques sur les pointeurs (voir 9.3.2.).