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à ?
1 – 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 : %dn », 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 : %dnn », 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.
2 – 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 : %ldn », &maVariable);
/* Affiche la valeur de maVariable */
printf(« Valeur de maVariable : %ldn », 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 : %ldn », 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.
3 – 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 : %dn », 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 : %dn », 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.
Dans le prochain chapitre nous verrons comment créer une table de données en C (appelés aussi tableau) et comment l’utliser dans nos petits programmes