Discussion :

[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?

[koala01]

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"

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct point
{  
    float coord[3];
};

et l'utilisation en deviendrait alors quelque chose ressemblant à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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)