Pointeur de structure
Un pointeur de structure se crée de la même manière qu'un pointeur de int, de double ou de n'importe quelle autre type de base :
Coordonnees* point = NULL; |
On a ainsi un pointeur de Coordonnees appelé point.
Comme un rappel ne fera de mal à personne, je tiens à vous répéter que l'on aurait aussi pu mettre l'étoile devant le nom du pointeur, cela revient exactement au même :
Coordonnees *point = NULL; |
Je fais d'ailleurs assez souvent comme cela, car pour définir plusieurs pointeurs sur la même ligne, nous sommes obligés de placer l'étoile devant chaque nom de pointeur :
Coordonnees *point1 = NULL, *point2 = NULL; |
Envoi de la structure à une fonction
Ce qui nous intéresse ici, c'est de savoir comment envoyer un pointeur de structure à une fonction pour que celle-ci puisse modifier le contenu de la variable.
On va faire ceci pour cet exemple : on va simplement créer une variable de type Coordonnees dans le main et envoyer son adresse à initialiserCoordonnees. Cette fonction aura pour rôle de mettre tous les éléments de la structure à 0.
Notre fonction initialiserCoordonnees va prendre un paramètre : un pointeur sur une structure de type Coordonnees (un Coordonnees*, donc).
int main(int argc, char *argv[]) { Coordonnees monPoint; initialiserCoordonnees(&monPoint); return 0; } void initialiserCoordonnees(Coordonnees* point) { // Initialisation de chacun des membres de la structure ici } |
Ma variable monPoint est donc créée dans le main.
On envoie son adresse à la fonction initialiserCoordonnees qui récupère cette variable sous la forme d'un pointeur appelé point (on aurait d'ailleurs pu l'appeler n'importe comment dans la fonction, cela n'aurait pas eu d'incidence).
Bien : maintenant que nous sommes dans initialiserCoordonnees, nous allons initialiser chacune des valeurs une à une.
Il ne faut pas oublier de mettre une étoile devant le nom du pointeur pour accéder à la variable. Si vous ne le faites pas, vous risquez de modifier l'adresse, et ce n'est pas ce que nous voulons faire.
Oui mais voilà, problème… On ne peut pas vraiment faire :
void initialiserCoordonnees(Coordonnees* point) { *point.x = 0; *point.y = 0; } |
Ce serait trop facile… Pourquoi on ne peut pas faire ça ? Parce que le point de séparation s'applique sur le mot point et non sur *point en entier. Or, nous ce qu'on veut, c'est accéder à *point pour en modifier la valeur.
Pour régler le problème, il faut placer des parenthèses autour de *point. Comme cela, le point de séparation s'appliquera à *point et non juste à point :
void initialiserCoordonnees(Coordonnees* point) { (*point).x = 0; (*point).y = 0; } |
Ce code fonctionne, vous pouvez tester. La variable de type Coordonnees a été transmise à la fonction qui a initialisé x et y à 0.
En langage C, on initialise généralement nos structures avec la méthode simple qu'on a vue plus haut.
En C++ en revanche, les initialisations sont plus souvent faites dans des « fonctions ».
Le C++ n'est en fait rien d'autre qu'une sorte de « super-amélioration » des structures. Bien entendu, beaucoup de choses découlent de cela et il faudrait un livre entier pour en parler (chaque chose en son temps).
Un raccourci pratique et très utilisé
Vous allez voir qu'on manipulera très souvent des pointeurs de structures. Pour être franc, je dois même vous avouer qu'en C, on utilise plus souvent des pointeurs de structures que des structures tout court. Quand je vous disais que les pointeurs vous poursuivraient jusque dans votre tombe, je ne le disais presque pas en rigolant !
Comme les pointeurs de structures sont très utilisés, on sera souvent amené à écrire ceci :
(*point).x = 0; |
Oui mais voilà, encore une fois les programmeurs trouvent ça trop long. Les parenthèses autour de *point, quelle plaie ! Alors, comme les programmeurs sont des gens fainéants (mais ça, je l'ai déjà dit, je crois), ils ont inventé le raccourci suivant :
point->x = 0; |
Ce raccourci consiste à former une flèche avec un tiret suivi d'un chevron >.
Écrire point->x est donc STRICTEMENT équivalent à écrire (*point).x.
N'oubliez pas qu'on ne peut utiliser la flèche que sur un pointeur !
Si vous travaillez directement sur la variable, vous devez utiliser le point comme on l'a vu au début.
Reprenons notre fonction initialiserCoordonnees. Nous pouvons donc l'écrire comme ceci :
void initialiserCoordonnees(Coordonnees* point) { point->x = 0; point->y = 0; } |
Retenez bien ce raccourci de la flèche, nous allons le réutiliser un certain nombre de fois. Et surtout, ne confondez pas la flèche avec le « point ». La flèche est réservée aux pointeurs, le « point » est réservé aux variables.
Utilisez ce petit exemple pour vous en souvenir :
int main(int argc, char *argv[]) { Coordonnees monPoint; Coordonnees *pointeur = &monPoint; monPoint.x = 10; // On travaille sur une variable, on utilise le "point" pointeur->x = 10; // On travaille sur un pointeur, on utilise la flèche return 0; } |
On modifie la valeur du x à 10 de deux manières différentes, ici : la première fois en travaillant directement sur la variable, la seconde fois en passant par le pointeur.
Créé avec HelpNDoc Personal Edition: Écrire des livres électroniques ePub pour l'iPad