Discussion :

[Porteuris]

voila j'ai fait un peu de C et je ne comprend pas du tout à quoi sert "public" dans les programmes C++ et Java j'ai chercher sur des tuto mais je n'y comprend pas plus

pouvez m'aidez svp???

[koala01]

Salut,

En POO (de manière générale), il y a un concept qui s'appelle "encapsulation".

Ce concept facilite le fait de ne permettre "au monde extérieur" d'accéder qu'à une partie restreinte du contenu d'une structure de données.

L'encapsulation fournit trois "visibilités" possible pour les variables et les fonctions qui appartiennent à une structure de données:

1. La variable (ou la fonction) ne peut être disponible qu'au travers des fonctions qui font partie même de la structure : c'est la visibilité privée (private: en C++, private en Java)
2. La variable (ou la fonction) peut être disponible de n'importe où dans le code (dés que l'on dispose d'une instance de la structure de données): c'est la visibilité publique (public: en C++, public en Java)
3. La variable (ou la fonction) peut enfin n'être disponible qu'au travers des fonction qui font partie de la structure, ou qui font partie de structures dérivées: c'est la visibilité protégée (protected: en C++, protected en Java)

Enfin, il y a quelques différences mineures entre le C++ et le Java:

• tu remarquera la présence du : en C++ (qui est supprimé uniquement lorsque le mot clé s'applique à l'héritage)
• Le mot clé s'applique uniquement à la fonction (ou à la variable) qui le suit en java, alors qu'il s'applique "jusqu'à indication contraire" (jusqu'à ce que l'on précise autre chose) en C++

En espérant que tu aies compris

[Porteuris]

je ne comprend toujours pas cette iddée de privée/publique qu'est ce que ça apporte au programme en generale notament dans une structure

[Melem]

Publique signifie que le membre que tu déclares est visible depuis n'importe où. Privé signifie que le membre que tu déclares n'est visible que depuis une fonction membre de cette même classe ou depuis une classe ou fonction amie (l'amitié est rarement un concept qu'on aborde dès les premiers pas en C++. Ca ne veut pas dire que c'est difficile à comprendre ...).

[koala01]

je ne comprend toujours pas cette iddée de privée/publique qu'est ce que ça apporte au programme en generale notament dans une structure

Cela permet de s'assurer du fait que, lorsque tu dispose d'une instance d'une structure de données particulière, tu n'ira pas chipoter à ce qui est étiqueté "touche pas à ca p'tit con" (référence à un film)

En déclarant une variable (ou une fonction) privée (ou protégée) tu va forcer l'utilisateur à passer par une fonction publique (à laquelle tout le monde a accès) pour modifier (ou récupérer) cette valeur ou pour appeler cette fonction.

Cela aura un effet assez génial: tant que tu ne modifie pas la signature de la fonction publique qu'il faut appeler, tu peux modifier "à ta guise" l'ensemble des données et des fonctions protégées ou privées (pour autant que tu respecte les objectifs de ta structure) sans que cela n'oblige l'utilisateur à revoir tout le code qu'il a écrit sur base de la première version de la structure.

Pour t'aider à comprendre, je vais prendre l'exemple de la représentation d'un point dans l'espace.

Pour représenter un point dans l'espace, tu a besoin de coordonnées sur trois axes nommés (par convention) x, y et z, représentant respectivement des coordonnées horizontale, verticale et de profondeur.

Tu pourrais donc créer une structure sous la forme de

Code :

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

1
2
3
4
5
6
struct Point3D // la visibilité par défaut de struct est publique :D
{
    int x; // ce pourrait être float ou double ou ... ;)
    int y;
    int z;
};

Mais, comme le type de x est le même que celui de y ou z, tu pourrait aussi envisager de la créer sous la forme de

Code :

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

1
2
3
4
struct Point3D
{
    int coordonnees[3];// ce pourrait être float ou double ou ... ;)
};

Ces deux codes représentent, finalement, exactement la même chose, mais, la manière dont tu va utiliser l'un n'est absolument pas compatible avec la manière dont tu va utiliser l'autre.

Cela implique que, si tu décide - pour une raison qui t'est propre - de passer de la première version à la deuxième (ou inversement) tu sera obligé de repasser l'ensemble de ton code en revue afin d'adapter chaque acces au contenu de ton Point3D à la nouvelle situation... Et ca va te demander un temps incroyable (d'autant plus grand que ton projet sera important).

L'idéal est donc de décider - avant d'écrire la première ligne de code - de "cacher" l'implémentation réelle de ces trois valeurs, et de décider qu'il n'y a que les fonctions qui appartiennent à Point3D qui peuvent y accéder: tu rend x, y et z (ou coordonnees)... privé.

Mais, disposer de valeurs auxquelles on ne peut pas accéder, ca ne sert pas à grand chose ...

Il faut donc prévoir des fonctions qui permettront d'accéder (en lecture) aux différentes valeurs ou de modifier ces valeurs.

Ces fonctions deviendront autant "point d'acces unique" aux valeurs, et devont être accessible "de n'importe où dans le code" (et donc avoir une visibilité publique).

Tu écrira donc ta structure Point3D sous la forme 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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
struct Point3D
{
    public: /* tout ce qui est accessible depuis n'importe où */
        // les fonctions permettant de changer les valeurs
        void setX(int newx)
        {
            // nous pouvons vérifier que newx est bien dans certaines limites
            x = newx;
            // nous pouvons décider de "faire autre chose" après
            // avoir redéfini x
        }
        void setY(int newy)
        {
            // nous pouvons vérifier que newy est bien dans certaines limites
            y = newy;
            // nous pouvons décider de "faire autre chose" après 
            // avoir redéfini x
        }
        void setZ(int newz)
        {
            // nous pouvons vérifier que newz est bien dans certaines limites
            z = newz;
            // nous pouvons décider de "faire autre chose" après 
            // avoir redéfini x
        }
        // les fonctions permettant de récupérer les valeurs
        int getX() const
        {
            return x;
        }
        int getY() const
        {
            return y;
        }
        int getZ() const
        {
            return z;
        }
    private: // tout ce qui est étiqueté "touche pas a ca ptit con"
        int x;
        int y;
        int z;
};

De cette manière, si un jour tu décide d'utiliser un tableau (int coordonnee[3]), tu n'aura qu'à adapter les 6 fonctions présentées pour que ton code (ou celui d'autres personnes) continue à fonctionner...

Tu te donne l'occasion d'apporter des modifications de manière strictement transparente par rapport à la plus grosse partie du code

Est-ce plus clair, maintenant

[EDIT]Cela te permet aussi de t'assurer que ta structure de données sera seule responsable des valeurs dont elle a besoin

[Porteuris]

Oui je crois que j'ai compris cette fois ^^

euh... c'est toi qui a ecrit tous ça??

[koala01]

Oui je crois que j'ai compris cette fois ^^

euh... c'est toi qui a ecrit tous ça??

Non, c'est la petite fée

[Goten]

A savoir que si tu ne spécifie rien dans le cas d'une struct tout ce qui suit est public, pour une classe c'est privée. (cas par défaut donc).