Discussion :

[curtis50]

j'voulais savoir pourquoi dit t'on que c++ est oriente objet.
Pourtant force est de constater que dans l'executable iln'ya pas de graphisme attrayant comme les images en couleurs .
Es ce possible de faire des coubrbes si oui je veu la commande avec un exemple concret .
p riere de m'l'envoyer par mail curtisjakson50cent@hotmail.fr

[Matthieu Brucher]

Ca n'a rien à voir, tu parles d'interface graphique, c'est complètement orthogonal à l'orientation objet.

[azalsup]

euhhh ... no comprendo ????

[zais_ethael]

Va apprendre ce que c'est que l'orienté objet avant de dire des bétises.

[NiamorH]

Va apprendre ce que c'est que l'orienté objet avant de dire des bétises.

J'aurais dit pareil en moins méchant quand même

[koala01]

Salut,

En fait, le terme "orienté objet" n'a strictement rien à voir avec une représentation graphique.

C'est plutôt une optique de programmation qui va consister, en très gros et sans entrer dans les détail, à considérer n'importe quelle donnée non pas en tant que "donnée" proprement dite, mais comme un "objet" qui est en mesure de réagir à certains "messages" qui lui sont envoyés, le tout en "cachant" à celui qui utilise l'objet la manière réelle dont les données sont implémentées/utilisées.

C'est à mettre en parallele avec d'autre conceptions de la programmation comme la programmation procédurale.

Ainsi, en procédural, pour gérer des personnes, tu créeras sans doute une structure qui contiendrait le nom, le prénom et l'adresse, et, chaque fois que tu aurais besoin d'une de ces informations, tu y accéderais directement sous un code qui pourrais ressembler à

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
 
struct Personne
{
    string nom;
    string prenom;
    string adresse;
};
 
int main()
{
    Personne moi;
    moi.nom="truc";
    moi.prenom="machin";
    moi.adresse="rue de la poupee qui tousse";
    /**/
    if(moi.nom != "bidule")
        cout<< "c'est pas bon vilain garcon";
    return 0;

seulement, voilà...

Si, un jour, après un tas de tests pour voir ce qui est le plus rapide, tu décide de remplacer la structure par quelque chose qui ressemble à

Code :

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

1
2
3
4
struct Personne
{
    string data[3];
};

qui reste une manière tout à fait cohérente de représenter les trois informations qui caractérisent une personne, tu devra parcourrir l'ensemble du code qui utilise la structure pour le modifier... et cela peut rapidement monter à plusieurs milliers de lignes à scruter

Mais, en plus, si ton voisin s'est dit "tiens, mais la structure est sympa, je l'utilise aussi" (le principe des bibliothèques ), lui aussi devra modifier son code, parce que la version 1 ne sera pas du tout compatible avec la version 2

En orienté objet, on va considérer qu'une personne doit pouvoir réagir à un certains nombre de messages, qui pourraient être:

• Crée toi (fournir le nom, le prénom et l'adresse)
• Identifie toi (affiche moi ton nom et ton prénom)
• Donne moi ton nom
• Donne moi ton prénom
• Donne moi ton adresse
• Démanage à (donner la nouvelle adresse)

(je décide volontairement ici d'estimer qu'il n'y a pas moyen de changer de nom )

On va donc "cacher" les informations de manière à ce qu'il n'y ai que la structure elle meme qui puisse y accéder, et créer des fonctions (que l'on appellera méthode pour la cause) qui induiront le comportement attendu pour les différents messages.

Cela prendrait une forme proche 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
 
class Personne
{
    /* les messages accessibles de partout */
    public:
        /* l'équivalent de "construit toi */
        Personne( const string& n, const string& p, const string a);
        /* l'équivalent de "identifie toi */
        void Identifie() const ;
        /* l'équivalent de "donne moi ton nom" */
        const string Nom() const;
        /* l'équivalent de "donne moi ton prenom" */
        const string Prenom() const;
        /* l'équivalent de "donne moi ton adresse" */
        const string Adresse() const;
        /* l'équivalent de "déménage" */
        void Demenage(const string& nadresse);
    /* les les données qui sont cachées à tout le monde */
   private:
        /*au choix, elle prennent la forme de */
        string data[3];
        /* ou de  */
        string m_nom;
        string m_prenom;
        string m_adresse;
};

Selon la manière dont les données seraient mise en mémoire, les comportements seraient codés 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
Personne::Personne(const string& n, const string& p, const string a):
      data[0](n),data[1](p), data[2](a)
{
 
}
void Personne::Identifie() const
{
    cout << "je m'appelle "<< data[0]<<" "<<data[1];
}
const string Personne::Nom() const
{
   return data[0];
} const string Personne::Prenom() const
{
    return data[1];
}
const string Personne::Adresse() const
{
    return data[2];
}
void Personne::Demenage(const string& nadresse)
{
    data[2]=nadresse;
}

ou 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
Personne::Personne(const string& n, const string& p, const string a):
      m_nom(n),m_prenom(p), m_adresse(a)
{
 
}
void Personne::Identifie() const
{
    cout << "je m'appelle "<< m_nom<<" "<<m_prenom;
}
const string Personne::Nom() const
{
   return m_nom;
} const string Personne::Prenom() const
{
    return m_prenom;
}
const string Personne::Adresse() const
{
    return m_adresse;
}
void Personne::Demenage(const string& nadresse)
{
    m_adresse=nadresse;
}

Tu me demanderas sans doute quel est l'avantage, et, en fait, il est simple...

En tant qu'utilisateur de la structure (qui est devenue une "classe" au passage ), je ne peux absolument plus accéder directement aux différentes informations...

Si donc j'essaye un code du genre de

Code :

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

1
2
    if(moi.nom != "bidule")
        cout<< "c'est pas bon vilain garcon";

le compilateur ne sera pas d'accord...

Et, pourtant, je peux faire tout ce que je faisais avant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
    /* je peux créer une personne */
    Personne moi("truc","machin","rue de la poupee qui tousse");
    /* je peux demander de s'identifier */
    moi.Identifie();
    /* je peux vérifier le nom */
    if(moi.Nom()!= "bidule")
        cout<< "c'est pas bon vilain garcon";
    /*...*/
    return 0;
}

MAIS si je décide de modifier la manière dont les informations sont maintenues en mémoire (passer de trois "string" séparée à un tableau de "string" ou vice versa), je n'aurai QUE les comportements à modifier:

• Personne(),
• Identifie(),
• Nom(),
• Prenom(),
• Adresse(),
• Demenage()

C'est à dire 6 lignes en tout et pour tout... Quel que soit le nombre de fois où ces comportements sont appelés dans le reste du code...

Et le mieux, c'est que ceux qui utiliseront ma bibliothèque ne se rendront sans doute jamais compte que j'ai effectué des changements dans la structure de mes données entre "la version 1" et "la version 2"

Ensuite, il y a une série d'autres concepts connexes, mais leur explications sortent du simple cadre d'un forum (en plus, j'ai déjà écrit un roman )