---------------------------------------------------------------------------------------
V.                Language C : Comprendre les Pointeurs                          MeiK
---------------------------------------------------------------------------------------



[ Introduction ]

Beaucoup de débutants butent un moment sur les pointeurs lorsqu'ils apprennent 
à programmer en langage C. Et encore, même certains programmeurs de niveau moyen 
rencontrent quelques difficultés avec les pointeurs. Vu qu'il semble que ce soit 
un problème pour la majorité, je me suis senti presque obligé de faire un article 
là dessus.




  I. Qu'est-ce qu'un pointeur ? :
  _______________________________


Avec les mots les plus simples, un pointeur est une variable qui garde en mémoire 
l'adresse d'une  autre variable. C'est un peu comme l'adresse que vous mettez sur 
une enveloppe (bon, on est à l'ère de l'e-mail, mais c'est toujours d'actualité). 
Cette adresse pointe vers la maison de la personne à qui vous voulez envoyer la 
lettre. Le pointeur garde simplement l'ADRESSE. De la même manière que l'enveloppe 
a l'adresse de la personne, elle *pointe* vers la personne.

Vous avez compris ? Vous voyez donc que c'est simple jusque là...

Ensuite, pourquoi on trouve que c'est une façon chiante de faire les choses est un 
autre sujet que vous découvrirez un peu plus tard dans cet article.




  II. Déclarer des pointeurs : 
  ____________________________


Déclarer un pointeur est une chose très simple :

char *pointeur;

Dans ce cas, le pointeur pointe vers l'adresse mémoire d'une variable de type 
CHAR. Notez que ça doit pointer vers une variable de type CHAR et non un autre 
type. Le compilateur risque de vous faire chier si vous mettez pas le bon type. 




  III. Utiliser les pointeurs :
  _____________________________


Maintenant on va faire un petit échange. On va échanger le contenu de deux 
variables en utilisant des pointeurs :

int var1 = 13, var2 = 69, temp;
int *pointeur;


pointeur = &var1;		/* Au cas ou vous ne savez pas que &var1 est  "adresse de */
                                /* "l' adresse de l'emplacement du contenu de var1" et non */
                                /* le contenu actuel de var1 lui-meme */

temp = *pointeur;		/* Copie la valeur de la variable pointée par 'pointeur' */
                                /* dans la variable 'temp', dans ce cas là, 'var1 */


*pointeur = var2;		/* Copie le contenu de var2 à l'adresse pointée par le pointeur*/

var2 = temp;			/* copie le contenu de var2 dans temp */

On a juste échangé les valeurs en utilisant les pointeurs. Bon, ça peut sembler 
sans intérêt, mais ça montre bien comment s'utilisent les pointeurs.




  IV. L'Opérateur d'Adresse :
  ___________________________


Je pense qu'il est grand temps de s'occuper de l'opérateur d'adresse car il y a 
quelques petits détails utiles que vous devriez connaître à propos de ce dernier. 
Il y a quelques trucs que vous ne pouvez pas faire avec l'opérateur d'adresse ; 
certains peuvent sembler évidents, d'autres pas.

-[1]-

var_adresse = &13;
Vous ne pouvez pas utiliser l'opérateur d'adressage avec des constantes.

-[2]-

var_adresse = &(valeur + 69);
Vous ne pouvez pas utiliser l'opérateur d'adressage dans des expressions 
impliquant l'utilisation d'opérateurs tels que + et -. 

-[3]-

var_adresse = ®
Vous ne pouvez pas utiliser l'opérateur d'adressage en précédant des variables 
register étant donné la définition register reg.




  V. Pointeurs et Tableaux :
  __________________________


Les pointeurs et les tableaux sont assez liés et sont ainsi confondus. 
Voyons le morceau de code suivant : 

float salaire[50];
float *float_ptr;

Maintenant on considère :

float_ptr = salaire;
float_ptr = &salaire[0];

Bon, ces deux instructions font la même chose. Elles font que float_ptr 
pointe vers le premier élément du tableau 'salaire'.

Une chaine constante (comme "Input Output Corporation") est stockée dans un 
tableau de caractères avec un caractère de fin en tant que dernier caractère. 
Mais regardez ce qui suit :

char *char_ptr = "Input Output Corporation";

Ca définit non seulement le pointeur, mais ça l'initialise aussi à l'adresse 
du premier caractère dans la chaine. La même chose aurait pu être écrite de la 
façon suivante :

char *char_ptr;
char_ptr = "Input Output Corporation";



  VI. "Pointeurs à pointeurs" :
  ____________________________


Cela vous semble peut-être chiant, mais ça vous servira très souvent si vous 
commencez à coder beaucoup plus un jour. En fait, par ce titre, je voulais dire 
que c'est un pointeur qui pointe sur un pointeur qui pointe sur l'adresse d'une 
certaine variable. 

L'exemple le plus courant est certainement dans la fonction main() avec 
les paramètres qu'on lui passe depuis la ligne de commande :


int main(int argc, char *argv[]);

le char *argv (qu'on écrit aussi parfois char **argv[]) est un pointeur 
de pointeur. 





[ Conclusion ]

Que retenir de tout ça ? bien tout simplement que les pointeurs peuvent 
devenir assez utiles parfois, vous l'aurez vu dans la première partie. Bon, 
je sais pertinement qu'il y a des tas d'autres choses à dire sur les pointeurs, 
mais si vous êtes un débutant, vous découvrirez le reste de vous même ; si vous 
êtes déjà un programmeur avancé, vous devez déjà savoir.