[Débutant] Comment fonctionne les structures?

Version imprimable

30/07/2007, 12h08
uNd3r²

[Débutant] Comment fonctionne les structures?

Bonjour,

Suis débutant dans le C++ (comme indiqué dans le titre :D ), et j'ai ne comprend pas comment fonctionne les structures et à quoi peuvent t'elles bien servirent.
Et j'annonce que je suis allez voir les tutoriaux d'ici et d'autre et sur d'autres site web le résultat est le même : Rein compris :'(

Merci de pouvoir aider un pauvre noob en détresse :(
30/07/2007, 12h18
Ekinoks
salut uNd3r²,

Les structures servent essentiellement à regrouper des variables.
On peu par exemple imaginer la structure Coordonee :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 typedef struct Coordonee { int x; int y; int z; }Coordonee; void main() { Coordonee p; p.x = 2; p.y = 3; p.z = -5; }
30/07/2007, 14h14
uNd3r²
Okai merci bien, mais... j'ai pas toujours bien compris comment on s'en sert :traine:

Sur un totorial que j'ai trouvé sur Internet il me met ceci en tant que syntaxe :
Code:

1 2 3 4 5 struct Client { unsigned char Age; unsigned char Taille; } Jean;
Il n'y as pas devant struct "typedef" et puis pour terminer, comment faire pour se servir des variables que l'on a créé. Juste, par exemple, l'afficher avec la commande printf.

Merci :D

L'utilisation normale en C++ se fait avec la syntaxe suivante :
Code:

1 2 3 4 5 6 7 8 struct Mastructure { // contenu de la structure }; // Plus loin dans le code, on crée une instance de la structure Mastructure instance; instance.x = 32; // etc
Les typedef, c'est en C que l'on doit s'en servir.

30/07/2007, 14h33
aoyou
Code:

1 2 3 4 5 6 struct Client { unsigned char Age; unsigned char Taille; } Jean;
Dans ce cas particulier, tu déclares une variable Jean de type struct Client.

Typedef permet de rédéfinir un type, raccourcir le nom d'un type par exemple.
Tu pourras l'utiliser pour renommer un type structure.
Code:

1 2 3 4 5 6 7 8 struct Coordone_s { int x; int y; int z; }; typedef struct Coordone_s Coordone;
Ce que tu peux raccourcir en
Code:

1 2 3 4 5 6 7 typedef struct { int x; int y; int z; }Coordone;
Par contre, dans ces deux derniers exemples, tu ne déclares pas encore de variable Jean.

Une fois que tu as crée une variable, tu fais référence aux différents éléments de la stucture avec l'opérateur .
Code:

1 2 3 Jean.Age Jean.Taille
Donc pour un exemple avec printf
Code:

1 2 printf ("Jean a %d ans et mesure %d cm.\n", Jean.Age, Jean.Taille);
Tu ne peux pas directement afficher le contenu d'une structure.

Après tout ceci se fait plutôt en C mais l'exemple que tu as trouvé provient d'un cours de C/C++ qui mélange les deux langages.
30/07/2007, 14h51
Alp

Ce qui est une très mauvaise chose ;)

C'est comme utiliser void* en C++, c'est inapproprié, car le C++ propose de nouvelles choses, que ne propose pas le C, afin de remplacer void* par exemple (la généricité, en C++).

Et bien merci déjà, avec vos conseil et d'autres petit truc que je connaissais d'avant ; j'ai créé un petit programme bidon et je voudrais savoir ce que vous en pensiez et savoir comment l'optimisé car là il est simple mais je ne sais pas si je le fait devenir plus compexe sa marcheras encore.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <stdio.h> #include <iostream> struct Test { int x; int y; }; int main(void) { Test a; a.x = 32; a.y = 10; Test b; b.x = 2; b.y = 3; printf ("Valeur de X = %d , valeur de Y = %d \n", a.x, a.y); printf ("Valeur de X = %d , valeur de Y = %d \n", b.x, b.y); system("pause"); return 0; }
Et si j'ai bien compris l'utilité de cette fonction s'est de pouvoir créé des données toujours sur une même base?

En même temps s'est problématique si je compile du C et du C++ en même temps?

30/07/2007, 16h13
Ekinoks

Citation:

Envoyé par uNd3r²

Et si j'ai bien compris l'utilité de cette fonction s'est de pouvoir créé des données toujours sur une même base?

oui voila c'est ca =)

Citation:

Envoyé par uNd3r²

En même temps s'est problématique si je compile du C et du C++ en même temps?

Le C++ ajoute des chose en plus par raport au langage C, donc ce qui existe dans le C existe dans le C++.
Les structure existe et dans C et donc egalement dans le C++.
30/07/2007, 16h16
uNd3r²

Et bien merci à vous pour cette aide.

Bon il y a des chance pour que j'ai d'autres questions (supérieur à 99,99%).

Donc je dit [résolut] et encore une fois merci!

Par contre, autant commencer à prendre des bonnes habitudes et distinguer ce qui vient du C et ce qui vient du C++...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>     // C
#include <iostream>  // C++, en l'occurence, ne sert à rien ici
 
struct Test {  // C
 int x;
 int y;
};
 
int main(void) {
 Test a;               // Declaration C++
 a.x = 32;
 a.y = 10;
 Test b;             // Declaration C++
 b.x = 2;
 b.y = 3;
 printf ("Valeur de X = %d , valeur de Y = %d \n", a.x, a.y);    // C
 printf ("Valeur de X = %d , valeur de Y = %d \n", b.x, b.y);    // C
 system("pause");
 return 0;
}

30/07/2007, 20h08
uNd3r²
Désolé de contre dire mais cette ligne sert :
Citation:
Envoyé par aoyou

Code:

1 2 #include <iostream> // C++, en l'occurence, ne sert à rien ici
Car si je la retire la compilation ne marche pas, le compilateur met en erreur la fonction : system("pause");

Ok, si ça marche...

En fait, stdio.h en C est le pendant de iostream en C++. C'est pour ça que je ne voyais pas l'intérêt d'un doublon.

Normalement, pour la fonction system, on inclut stdlib.h en C et cstdlib en C++.

Si tu veux faire du vrai C++, je réécrirais ton code ainsi mais tu auras bien le temps de voir tout ça.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <iostream> struct Test { int x; int y; }; // La définition en C++ d'une structure est interdite par certaines règles de codage // qui préfèrent une classe avec des attributs publics. int main(void) { Test a; a.x = 32; a.y = 10; Test b; b.x = 2; b.y = 3; std::cout << "Valeur de X = " << a.x << " , valeur de Y = " << a.y << std::endl; std::cout << "Valeur de X = " << b.x << " , valeur de Y = " << b.y << std::endl; system("pause"); return 0; }

31/07/2007, 09h15
nikko34

La définition de structures n'est pas du tout interdite en C++, certaines règles, boost et le standard l'encouragent même.

Elles sont utilisés pour des functors qui ne gardent pas d'état, pour des "classes" simples comme std::pair etc..

Après, ça reste juste esthétique ou pratique. La seule différence entre les deux étant que la structure a ses données membres publiques par défaut contrairement à la classe qui les a privées.
31/07/2007, 09h59
aoyou

J'ai dit certaines règles de codage.
Personnellement, je suis pour :king: mais j'ai déjà eu à faire à des oppositions :aie: sur l'utilisation des structures en C++ et quand le client :evilred: il ne veut pas et ben il ne veut pas :( .
31/07/2007, 12h09
Alp

Il faut arrêter les coner^W^W.
Les deux seules différences entre structures et classes sont l'héritage par défaut (public pour les structures, privé pour les classes) et la visibilité des membres par défaut (publique pour les structures, privée pour les classes).

De plus, si quelqu'un ne veut ni des structures, ni des classes, qu'il reste en C, à grands coups de malloc, free, void*, et j'en passe.

Salut,

En fait, une structure permet d'"agréger", ou, si tu préfères, de regrouper, des données qui n'ont, de prime abord, rien de commun.

L'astuce, c'est que, non seulement cela regroupe les données, mais cela les rend indissociables.

Ainsi, un nom, un prénom et un âge (et, si on avait voulu, on aurait pu rajouter un tas de choses ;)) sont des données qui n'ont pas grand chose à voir:

Le nom fait référence à ton ascendance (c'est le nom de ton père, et de son père avant lui et de son père avant...)
Le prénom est la manière dont on s'adresse à toi dans l'intimité (car, je présume qu'on ne t'appelle pas "Hé toi" à la maison :D),
l'age n'est même pas une chaîne de caractères :P

Par contre, ces trois informations font référence à une seule personne: toi...

Si tu changes ne serait-ce qu'une seule information, ou pire, qu'une seule lettre dans le nom ou dans le prénom, ce n'est plus toi...

C'est ton frère, ton père, ta soeur, ton cousin, voir un parfait inconnu, mais ce n'est plus toi :P

Et, bien sûr, les raisons d'agréger plusieurs données sont légions: il est finalement bien plus rare de rencontrer une donnée (surtout dans un type de base) qui se suffit à elle même pour représenter un "tout" qu'un agrégat de différentes informations ;)

L'avantage des structures, en plus, c'est qu'il suffit de transmettre la structure à une fonction pour être sur que la fonction pourra disposer de l'ensemble des informations (ou, du moins, de celles qui sont accessibles) ;)

Il faut savoir qu'en C, une structure ne peut pas avoir de fonction membres.

De plus, le mot cle typedef n'est pas plus obligatoire en C qu'en C++... mais son absence rend l'utilisation plus difficile en C :P

Ainsi, rien ne t'empecherait, en C, de déclarer une structure sous une forme proche de
Code:

1 2 3 4 5 6 struct personne { char nom[50]; char prenom[20]; int age; };
L'astuce, c'est que tu devrais alors préciser, chaque fois que tu veux utiliser cette structure... qu'il s'agit d'une structure
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct personne CreePersonne(char* nom, char* prenom, int age); int main() { struct personne moi; strcpy(moi.nom,"koko"); strcpy(moi.prenom,"le koala"); moi.age=35; /*...*/ return 0; }
Par contre, si tu utilises le mot cle typedef, tu signalera au compilateur qu'il existe un type (comme si c'était un int, un char ou un float) du nom indiqué
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 typedef struct personne { char nom[50]; char prenom[20]; int age; }pers; /* tu peux toujours utiliser la structure personne si tu veux */ struct personne MaFonction(); /* mais il devient plus facile d'utiliser le type "pers" :D */ pers LautreFonction(); int main() { /* cela fera exactement la meme chose que dans l'exemple précédent */ pers moi; /*...*/ }
Voila ce que l'on pouvait dire pour reprendre certaines erreurs énoncées au niveau du C...

En ce qui concerne le C++, il y a quelques différences:

Les deux principales viennent du fait qu'une structure peut contenir des fonctions qui lui sont propres
Code:

1 2 3 4 5 6 7 8 9 struct personne { /* on "transforme" les données en types plus facile à utiliser ;) */ std::string nom; std::string prenom; int age; int CalculeAnneeDeNaissance(){/*...*/} };
et le fait que la notion de visibilité apparaît:

On peut en effet décider qu'une information est à usage "interne" uniquement.

De plus, en C++, il existe également la notion de classe.

De fait, tu faire avec une classe tout ce que tu fais avec une structure... Seule la visibilité par défaut est différente, ainsi qu'il a déjà été dit:

Si tu ne précise pas la visibilité (avec les mots clé private: protected: ou public: ) elle sera par défaut public pour les structure et private pour les classes.

Cependant, il y a une autre différence encore, même si, à ton niveau, uNd3r², cela risque encore de te passer quelque peu au-dessus de la tête (mais principalement pour signaler l'erreur aux autres ;)):

une structure ne peut pas être utilisée comme paramètre d'une classe ou d'une fonction template :P C'est souvent oublié, mais cela valait d'etre dit :D

01/08/2007, 12h11
nikko34

Citation:

une structure ne peut pas être utilisée comme paramètre d'une classe ou d'une fonction template :P C'est souvent oublié, mais cela valait d'etre dit :D

t'halucines non? ou alors je n'ai pas compris ce que tu veux dire.
01/08/2007, 13h51
uNd3r²

Okay okay,

alors moi qui pensais avoir compris et bien enfaite j'ai vu que la partie immergée de l'iceberg (elle était bien trouvé c'elle là non? ^^ ).

Bon alors pour commencer.
Cette histoire de privée public j'y est rien compris sa change quoi? J'ai vite fait aperçu pendant un tutorial mais j'ai compris uniquement que sa existaient.
De plus s'est quoi l'héritage des classes?

(enfaite j'aurais pas dut mettre le tag [résolut] :cry: )
01/08/2007, 14h09
aoyou

En fait, tu en es encore à tes balbutiements d'apprentissage. Ta question, certes très bonne, a entraîné une profonde discussion sur la différence entre le C et le C++ sur les structures mais elle a dû t'emmêlée les pinceaux.

Tu devrais continuer de suivre tes tutoriaux et uniquement sur le C++, si bien sûr tu veux apprendre le C++ et non le C. Si tu suivais uniquement des tutoriaux de C++, tu aurais déjà du voir la notion de classe, d'attributs publics et privés et non la notion de structure (qui n'est pas essentiel à ce niveau). L'héritage des classes vient un peu plus loin et ça c'est essentiel.

Désolé de t'avoir montré la partie immergée de l'iceberg mais on n'aurait pas du te la montrer, enfin pour le moment.

Bon courage pour la suite de ton apprentissage.

Par contre, si tu ne comprends pas un point précis ou un bout de code de ton tutorial, on est toujours là.

Bon, et puis si tu veux vraiment savoir, voici des pointeurs qui pourront t'aider
http://c.developpez.com/faq/cpp/?pag...ASS_definition
http://c.developpez.com/faq/cpp/?pag...private_public
http://c.developpez.com/faq/cpp/?pag...e_class_struct
http://c.developpez.com/faq/cpp/?pag...ITION_heritage
02/08/2007, 02h04
koala01

Nous allons donc essayer de te faire voir un peu de ce qui se passe sous l'eau, histoire de te donner directement les bonnes bases :D

Les mots clé private, protected et public (ou, si tu préfères en français - mais est-ce réellement utile:question:- privé, protégé et public) participent à ce que l'on appelle entre nous l'encapsulation des données.

Tu remarqueras au fur et à mesure qu'il existe le plus souvent plusieurs possibilités pour représenter une seule et même chose...

L'astuce, c'est que ces différentes possibilités sont - souvent - incompatibles entre elles :P

Du coup, si on laisse, comme en C, les données accessibles à tous, chaque fois que l'on décide de changer la manière de représenter quelque chose, il faut rechercher parmi toutes les fonctions chaque utilisation de la donnée que l'on a changé, ce qui fait très vite énormément de boulot.

L'idée de base est donc simple: cachons le plus possible la manière dont les données sont représentées afin d'éviter que n'importe qui n'aille mettre ses "grosses pattes pleines de doigts" dessus, mais fournissons les fonctions qui permettent d'obtenir - et de modifier s'il échoit - les valeurs.

De cette manière, nous serons sûrs, si nous décidons de modifier la manière dont une donnée est représentée, qu'il n'y a que très peu d'endroits où la représentation elle-même est utilisée: en gros, il n'y aura que les fonctions qui permettent d'obtenir ou de modifier les dites valeurs.

Le mot clé private permet donc de dire

Citation:

Attention, cette information n'est accessible qu'au travers de la structure elle-même

Si une fonction qui n'appartient pas à la structure essaye d'accéder ou de modifier une donnée privée, le compilateur se plaindra en te disant que "telle donnée est privée dans ce contexte".

A contrario, le mot clé public permet de dire

Citation:

cette donnée ou - car généralement on veille à ce qu'il n'y ai que des fonctions - cette fonction est accessible de n'importe où

Comme la fonction fait partie de la structure, elle peut très bien accéder aux informations (ou aux fonctions) qui sont déclarées privées, et on peut faire appel à la fonction au départ de n'importe quel endroit du code...

Le mot clé protected enfin nécessite que l'on s'intéresse peut être un peu à ta dernière question (qu'est ce que l'héritage)...

Quand, dans la vie de tous les jours, tu hérites de quelqu'un, cela signifie simplement que tu reçois l'ensemble de ce que la personne pocédait.

L'idée est ici exactement la même, simplement, un type qui hérite d'un autre en reçoit non seulement toutes les données mais aussi toutes les fonctions..

La notion d'héritage implique une filiation entre deux types.

C'est à dire que si tu as un type particulier qui dispose de toutes les caractéristiques d'un type un peu plus "généraliste", c'est vraisemblablement parce que le type particulier hérite du type généraliste

Le plus souvent, on parlera de relation est un (en anglais: an is a relation) pour indiquer qu'il s'agit du fait que le premier hérite du deuxième...

Ainsi, vu que l'on peut dire

Citation:

un chien est un mammifère

ou

Citation:

une voiture est un véhicule

Nous pourrions très bien traduire ces deux relations sous les formes

Citation:

la classe chien hérite de la classe mammifère

ou que
[QUOTE]la classe voiture hérite de la classe véhicule/QUOTE]

Dans ces deux phrases, les classes mammifère et véhicule seront appelées classes (ou strutures) de base ou classes (ou structures) mères alors que les classes chien et voiture seront appelées classes (ou structures) dérivées, ou classes (ou structures) enfants

Si l'on voulait être complet, on pourrait conclure le chapitre de l'héritage en indiquant qu'il peut y avoir de l'héritage public, de l'héritage protégé et de l'héritage privé... Mais j'attendrai peut être que tu aies digéré l'ensemble de ce post avant d'en parler :P:D

Il est temps, maintenant de s'inquiéter du dernier mot clé: protected

Il est fort proche du mot clé private, parce que la donnée ou la fonction qui est déclarée protégée n'est pas accessible au dehors de la structure dans laquelle elle est déclarée, mais avec la nuance rajoutée que

Citation:

Mais si une structure vient à hériter de celle dans laquelle sont déclarées les données protégées, la structure dérivée pourrait accéder aux données protégées de la structure de base exactement comme si c'étaient les siennes

Cela devient, en quelque sorte, des données privées... mais pas trop :D
04/08/2007, 22h17
uNd3r²

Okay okay, je pense avoir un peu mieux compris.

Donc je récapitule. Les sructures peuvent avoir 3 types. Private , Protected et Public.

Private --> Ses données (je sais pas si je peut y appeller comme ça) ne peuvent modifiées que dans la structure elle même. En gros entre les crochet "{" et "}".

Protected --> Ses données peuvent être modifé que dans sa structure et ses "héritiers".

Public --> Peut être modifié n'importe où.

Donc si ce que j'ai résumé est juste, c'est 3 mots clés servent à protéger certes ; mais s'est juste pour nous, le programeur, pour éviter de faire des boullettes de compilation ou s'a un autre intérêt?

PS : Désolé si je pose baucoup de question mais le forum est fait pour sa non? :mrgreen:

Tu as a peu près bien compris le principe, sauf que private, protected et public ne sont pas des types...

Ce sont ce que l'on appellerait plutôt des spécificateurs de visibilité.

En informatique, on parle de type quand il s'agit de quelque chose qui permet de déclarer une variable:

int, char, float, std::string, etc sont des types alors que private, protected et public permettent de signaler que la visibilité de tout ce qui suit est privée, protégée ou publique, jusqu'à ce qu'on précise une autre visibilité.

En outre, le but de l'encapsulation des données est plus large que le simple fait d'éviter les boulettes de compilation: d'ailleurs, cela n'a en définitive que peu à voir avec la compilation...

L'idée est, surtout de se faciliter le travail en assurant une certaine tolérance quant à la manière dont les choses sont envisagée.

Si on travaille correctement, l'une des premières étapes du processus global que l'on peut appeler "création d'application" est... d'analyser et de définir les besoins.

Le problème est que les besoins de l'application évoluent, pour ainsi dire, en permanence pour une série de raisons... et que le fait que l'utilisateur et le développeur ne sont en réalité qu'une seule et même personne ne change rien à ce fait.

Si, par exemple, tu voulais créer une application qui dessine des formes géométriques, tu commencerais peut être en voulant qu'elle puisse dessiner des triangles, des élipses et des rectangles, le cercle n'étant qu'une particularité de l'élipse et le carré n'étant qu'une particularité du rectangle.

Mais, "à l'usage", que ce soit en cours de développement ou parce que tu utilise déjà pleinement l'application, tu te rendra sans doute compte que "ce serait si bien si elle pouvait aussi tracer toutes ces formes qui terminent en *gone...", ou "et si on lui permettait de tracer des volumes:question:"

Le tout, sans compter tous les cas dans lesquels, à l'usage et pour des raisons de performances ou de facilité, tu préféreras carrément changer la manière dont les données d'une structure sont représentées en mémoire...

Pour t'en convaincre, je vais simplement prendre l'exemple d'un point en coordonnées spatiale: une coordonnée x, une autre y et une troisième z, représentant les trois dimensions couramment utilisées.

Tu pourrais créer une structure dans laquelle les trois données seraient considérées comme publiques.

En C++, cela se traduirait sous une forme proche de
Code:

1 2 3 4 5 6 struct point { float x; float y; float z; };
Le problème, du fait que les données sont accessibles de partout, c'est que tant le programmeur que l'utilisateur, si tu décide de fournir l'application sous forme de bibliothèque sera tenté d'accéder directement à ces données...

Les endroits dans l'application qui utilise cette bibliothèque où l'on trouvera alors un code proche de
Code:

1 2 3 4 point var; var.x=8.3356; var.y=2.9972; var.z=0.0;
vont alors se multiplier plus vite que des souris prises de frénésie reproductrice...

Comme je te l'ai indiqué plus haut, il y a toujours plusieurs moyens de faire une même chose en informatique.

Ainsi, tu pourrais très bien décider de modifier ta structure point sous une forme proche de
Code:

1 2 3 4 struct point { float coord[3]; };
et l'utilisation en deviendrait alors quelque chose ressemblant à
Code:

1 2 3 4 5 point var2; var2.coord[0]=8.3356;/* ancienne version var.x...*/ var2.coord[1]=2.9972;/* ancienne version var.x...*/ var2.coord[2]=0.0;/* ancienne version var.x...*/
Le pire, c'est que, non seulement, le code du programmeur sera atteind, mais aussi le code de celui qui utilise la bibliothèque fournie par le programmeur 8O :cfou: :mur:

L'idée de base est donc de se dire que

Citation:

je vais cacher tout ce qui dépend clairement de l'implémentation en mémoire, et je vais fournir des fonctions qui permettent de faire le travail...

La structure, qui devient pour la forme une classe, deviendrait alors dés le départ quelque chose du genre de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class point { public: /* tout ce qui suit est accessible à tous */ point(float x=0.0, float y=0.0, float z=0.0); /* -- 1 -- */ ~point() /* -- 2 -- */ float GetX() const; /* -- 3a -- */ float GetY() const; /* -- 3a -- */ float GetZ() const; /* -- 3a -- */ void SetX(float newx); /* -- 3b -- */ void SetY(float newy); /* -- 3b -- */ void SetZ(float newy); /* -- 3b -- */ private: /* tout ce qui suit n'est accessible que depuis la classe elle même * que l'on décide donc d'utiliser un tableau de trois réels ou trois réels * séparés ne changera strictement rien :D */ float x; /* -- 4 -- */ float y; /* -- 4 -- */ float z; /* -- 4 -- */ };
Tu remarqueras sans doute que j'ai placé une numérotation à coté des différents éléments... en voici l'explication:

-- 1 -- C'est une fonction particulière qui s'appelle le constructeur. Il est appelé automatiquement quand on déclare une variable de type point, cette fonction s'occupe de donner les valeurs utiles à x, y et z
-- 2 -- C'est une autre fonction particulière qui s'appelle le destructeur. Il est appelé automatiquement quand une variable de type point cesse d'exister et prend normalement en charge la libération de toutes les ressources monopolisée par la variable
-- 3a -- Les trois fonctions qui permettront de récupérer la valeur de chacune des trois dimensions... Aussi bien le programmeur que l'utilisateur de la bibliothèque n'auront que ces trois fonctions pour y arriver
-- 3b -- les trois fonctions qui permettent de modifier les valeur de chacune des trois dimensions... Encore une fois, c'est le seul moyen d'y arriver
-- 4 -- la manière dont on aura décidé de représenter x, y et z en mémoire. L'accès à ces valeurs ne pourra se faire qu'au travers des fonctions expliquées plus haut :D

Si, pour une raison ou une autre, tu décide de modifier la représentation en mémoire de x, y et z et de passer à un tableau de réel, les seuls endroits de l'ensemble de tout le code, aussi bien du programmeur que de l'utilisateur de la bibliothèque, qui devront être modifiés, ce seront les fonctions de la classe (le constructeur, *éventuellement* le destructeur et les fonctions expliquées en 3a et en 3b)