En C une déclaration telle que:
struct point { int x; int y; };
définit un "type structure" appelé point(ou le plus souvent : la structure point, bien que cela définisse à la fois la structure point et un objet de type structure point). Pour x et y ce sont deux variables de type int qui représentent les champs ou les membres de la structure point.
Pour déclarer des variables de type point on utilise une déclaration du type:
struct point a,b;
a et b sont deux variables de type point dans lesquelles il existe deux sous-variables x et y. On accède à ces variables grâce à l'opérateur point (.); par exemple :
a.x
nous permet d'accéder directement au membre x de la structure a.
Grâce au C++ nous allons pouvoir associer aux données de la structure, constituée par les membres, des méthodes (fonctions membres) directement définies dans la structure. Rappelons que puisqu'il n'existe pas d'encapsulation des données cette démarche est purement artificielle, mais d'un point de vue conceptuel elle permet de mieux envisager la programmation, et aussi de préparer à la notion de classe.
Nous venons de déclaré une structure point symbolisant un point dans un plan, pour utilisé cette structure nous souhaitons créer trois fonctions :
- initialise pour affecter des "coordonnées" à un point.
- deplace qui modifie les valeurs de x et y.
- affiche qui ,par simplicité, affichera les coordonnées du point.
Voici la nouvelle déclaration de la structure point :
/*******Déclaration du type point*******/
struct point
{
int x;
int y;
void initialise(int ,int);
void deplace(int ,int);
void affiche();
};
Maintenant la déclaration de la structure a été enrichie de la déclaration (en-tête) de nos 3 fonctions. Vous remarquerez que nous n'avons pas défini les fonctions à cet endroit, mais elle se fera un peu plus loin.
Dans la déclaration de initialise vous constatez que nous passons en paramètres deux variable du type int mais que nous ne passons pas de structure sur laquelle travailler. En effet cette information sera directement fournie à la fonction membre lors de son appel, nous verrons comment par la suite.
La définition de la fonction membre initialise pourrait être :
void point::initialise(int abs, int ord) { x=abs; y=ord; }
Dans l'en-tête, le nom de la fonction est
point::initialise
initialise est le nom de la fonction membre de la structure point, "point::" signifie que cette définition de fonction est rattachée à la fonction membre initialise déclarée dans la structure point. L'opérateur "::" est en C++ l'opérateur de "résolution de porté" c'est lui qui fait le lien entre la déclaration et la définition de la fonction membre. En général nous aurons une déclaration de la forme :
Nom_Structure::Nom_Fonction
Nom_Structure est le nom d'une structure quelconque et Nom_Fonction le nom d'une fonction membre de la structure Nom_Structure.
Sans "point::" nous aurions définit une nouvelle fonctions initialise sans aucun rapport avec la structure point.
Vous remarquerez que :
x=abs
est une affectation qui affecte la valeur de abs à x, qui n'est ni une variable locale ni un argument, mais un membre d'une structure point. Mais rien dans la définition ne nous permet de savoir quelle est la structure concernée. Cette information sera transmise à la fonction membre initialise lors de son appel.
/****Définition des fonctions membres du type point******/
void point::initialise(int abs, int ord)
{
x=abs;
y=ord;
}
void point::deplace(int dx, int dy)
{
x += dx;
y += dy;
}
void point::affiche()
{
cout<<"je suis en"<<x<<" "<<y<<"\n";
}
Nous pourrions accéder à la structure a directement :
a.x=4; a.y=6;
mais nous n'utiliserions pas alors les méthodes crées a cet effet et nous ne respecterions pas le principe d'encapsulation des données (bien que cela ne soit pas interdit par C++). L'utilisation d'une fonction membre se fait comme suit :
a.initialise(4,6);
Le préfixe "a." signifie que la méthode initialise va s'appliquer à la structure a, elle prend en paramètres les valeur 4 et 6, ainsi les instructions :
x=abs; y=ord;
vont s'appliquer au membre x et y de a. Sans le préfixe "a." l'appel de la fonction membre point::initialise et pareil qu'une fonction ordinaire.
Nous pouvons déclarer autant de structure point, et donc de champs x et y propre a chacune de ces structures, que la place mémoire nous le permet, mais il n'en est pas pareil pour les fonctions membres qui ne sont générées qu'une seule fois dans le code.
