Vous êtes sur la page 1sur 6

Chapitre 7: Les pointeurs - Langage C

Pointeur, ce mot, qui parait pourtant inofensif, a fait trembler des générations de cerveaux de
programmeurs.

En effet, le problème avec les pointeurs c'est que leur fonctionnement est assez difficile a
assimilé pour les débutant, mais qu'il reste la clé de nombreux programmes. Le systèmes
d'exploitation que vous utiliser actuellement en est constitué !

Mais alors, qu'est ce donc que cette chose là ?

Qu'est ce qu'un pointeur ?

Concrètement, un pointeur est une variable contenant l'adresse d'une autre variable stockée en
mémoire

Dis comme cela c'est un peu barbare et ça doit surtout vous embrouillez, c'est pourquoi avant
de détaillé ma définition du pointeur , il me semble important que vous soyez au clair avec le
fonctionnement de la mémoire vive.

Si ce n'est pas le cas je vous invite à allez lire mon tutoriel sur la mémoire d'un ordinateur,
sans quoi la compréhension de la suite du tutoriel va s'avérer très compliquée

Lorsque vous créez une variable par exemple :

Code c:
int maVariable = 10;

Vous savez donc que la valeur "10" est stockée dans une "case" de la mémoire et qu'on peut y
accéder facilement en l'identifiant dans le programme par son nom. Le problème c'est que ceci
ne marche que dans la fonction dans laquelle est déclarer la variable. Ainsi le programme :

Code c:
#include <stdio.h>
#include <stdlib.h>

void maFonction();

int main()
{
int maVariable = 10;
printf("Valeur de maVariable : %d\n", maVariable);
maFonction();
return 0;
}

void maFonction()
{
printf("Valeur de maVariable dans maFonction : %d", maVariable);
}

Nous donnes une belle erreur de compilation en nous indiquant que la variable maVariable
n'est pas déclarée dans le fonction maFonction. Car en fait la "portée" d'une variable ne se
situe que dans la fonction où celle ci est déclarée, ainsi maVariable étant déclarée dans la
fonction main on ne peut avoir accès à la valeur qui lui est associé que dans la fonction main.

On ne peut donc pas modifier directement la valeur d'une variable depuis une autre
fonction que celle de sa déclaration

Pour exemple vous pouvez tenter ce programme :

Code c:
#include <stdio.h>
#include <stdlib.h>

void maFonction(int maVariable);

int main()
{
int maVariable = 10;

printf("Valeur de maVariable : %d", maVariable);


maFonction(maVariable);
printf("\nValeur de maVariable apres le passage dans maFonction :
%d\n\n", maVariable);
return 0;
}

void maFonction(int maVariable)


{
maVariable = maVariable + 6;
printf("\nValeur de maVariable dans maFonction : %d", maVariable);
}

Qui nous donne :

Code console:
Valeur de maVariable : 10
Valeur de maVariable dans maFonction : 16
Valeur de maVariable apres le passage dans maFonction : 10

Les pointeurs vont donc nous servir à faire face à ce problème. En effet nous allons en fait
créer une variable contenant comme valeur l'adresse d'une autre variable. Ainsi imaginons que
nous ayons une variable contenant la valeur 25 et stockée à l'adresse 5000. Et bien nous allons
créer une autre variable, appelé pointeur, qui contiendra comme valeur l'adresse de la
première variable et stockée à l'adresse 4130, ce qui schématiquement donne :

Enfait un pointeur n'est donc rien de plus qu'une variable contenant EXCLUSIVEMENT
l'adresse d'une autre variable. Cependant il nous faudra utiliser une synthaxe spécial.
Voyons donc comment créer un pointeur et l'utiliser dans un programme.

Utiliser les pointeurs

Pour créer un pointeur, on utilise le symbole de l'astérisque devant le nom du pointeur( " * ").
En revanche son initialisation ne se fait pas en lui donnant la valeur zéro, mais plutôt avec le
mot-clé NULL, ce qui nous donne :

Code c:
int *monPointeur = NULL;

On a donc ici un pointeur de type int se nommant "monPointeur";

Il va maintenant falloir lui envoyer en valeur l'adresse d'une variable. Voilà comment on va
procédé :

Code c:
int main()
{
int *monPointeur = NULL;
int maVariable = 10;

monPointeur = &maVariable;

/* Suite du code */

On envoie donc l'adresse de maVariable grâce au signe "&" devant son nom. En fait ce "&"
permet de signaler au sytème d'exploitation que l'on utilise, non pas la valeur de la variable
maVariable, mais son adresse en mémoire. Vous vous rappelez sans doute de cette synthaxe
qu'on retrouvait dans la fonction scanf

Maintenant que le pointeur monPointeur contient l'adresse de la maVariable nous pouvons en


faire, ce que l'on veux .
Voyons déjà comment afficher la valeur de la variable sur laquelle pointe notre pointeur :

Code c:
int main()
{
long maVariable = 10;
long *monPointeur = NULL;

monPointeur = &maVariable;

/* Affiche l'adresse de ma Variable grâce au "&"*/


printf("Adresse de maVariable : %ld\n", &maVariable);

/* Affiche la valeur de maVariable */


printf("Valeur de maVariable : %ld\n", maVariable);

/* On affiche l'adresse contenu dans notre pointeur en utilisant la


syntaxe
classique pour afficher une variable */
printf("Adresse contenue dans le pointeur monPointeur : %ld\n",
monPointeur);

/* On affiche la valeur de la variable se trouvant a l'adresse contenu


par monPointeur
en rajoutant une symple étoile ( " * ") devant le nom du pointeur */
printf("Valeur de la variable se trouvant a l'adresse contenu par
monPointeur : %ld", *monPointeur);

return 0;
}

Les commentaires parlent d'eux mêmes, il n'y a pas grand chose d'autre à rajouter.
Lorsqu'on débute, il est vrai qu'on ne trouve pas vraiment l'intérêt de se compliquer la vie
avec des pointeurs alors que la variable maVariable nous suffisait amplement pour nos
manipulations. C'est une réaction légitime, mais le gros intérêt des pointeurs c'est qu'ils vont
nous permettre de modifier la valeur d'une variable depuis une autre fonction que celle dans
laquelle, elle était déclarée (ce qui était impossible auparavant ).

Voyons donc comment envoyer et utiliser un pointeur dans une fonction.

Envoyer et utiliser un pointeur dans une fonction

On peut envoyer de plusieurs manières un pointeur à une fonction.

 En envoyant directement l'adresse d'une variable à un pointeur.


 En envoyant un pointeur (qui contiendra donc l'adresse d'une variable) a la fonction.
Code c:
#include <stdio.h>
#include <stdlib.h>

void maFonction(int *pointeur);

int main(void)
{
int maVariable = 10;

/* Avant l'appel de la fonction maVariable vaut 10 */


printf("Valeur de maVariable avant l'appel de fonction : %d\n",
maVariable);

/* On envoie l'adresse de maVariable à maFonction */


maFonction(&maVariable);

/* La valeur de maVariable a été modifiée elle vaut maintenant 5 ! */


printf("Valeur de maVariable apres l'appel de fonction : %d",
maVariable);

return 0;
}

void maFonction(int *pointeur)


{
/* Ce pointeur va directement modifier la valeur de maVariable pour la
mettre à 5 */
*pointeur = 5;
}

Dans ce petit programme, la variable maVariable est donc initialisée à 10. On envoie ensuite
son adresse (en tant que paramètre) à la fonction maFonction. Le pointeur pointeur dans ma
fonction reçoit donc l'adresse de maVariable. Ensuite il modifie la valeur de celle ci pour la
mettre à 5.

Mais on peut envoyer d'une autre manière un pointeur à une fonction :

Code c:
void maFonction(int *pointeur);

int main(void)
{
int maVariable = 10;
int *monPointeur = &maVariable;

printf("Valeur de maVariable avant l'appel de fonction : %d\n",


maVariable);
maFonction(monPointeur);
printf("Valeur de maVariable après l'appel de fonction : %d",
maVariable);

return 0;
}

void maFonction(int *pointeur)


{
*pointeur = 5;
}

Que se passe t'il concrètement ici ? Et bien on envoie non plus l'adresse de maVariable, mais
un pointeur (ici monPointeur) qui contient l'adresse de maVariable.

Rappelez vous pour avoir la valeur d'une variable dont l'adresse est contenu dans un pointeur,
il suffisait de rajouter le symbole de l'astérisque devant le nom de ce pointeur. Mais si on
souhaite avoir l'adresse de cette variable, il suffit simplement d'indiquer le nom de ce pointeur

pointeur reçoit donc comme valeur l'adresse de maVariable et peut donc modifier directement
celle-ci en mémoire.

Vous savez maintenant comment fonctionne les pointeurs en C. Ils sont très utiles malgrés ce
qu'on a pu voir dans ces petits exemples. Je vous recommande bien vous entrainer en
réécrivant de petit programme les utilisant. Tiens essayer donc d'envoyer deux pointeurs à une
fonction pour modifier la valeur de 2 variables . Si vous avez un quelconques problèmes de
compréhensions ou autres n'hésitez pas à allez poster sur le forum.