Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.
poo [2014/09/16 21:49] gbdivers |
poo [2019/12/27 19:58] (Version actuelle) gbdivers créée |
||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
- | ^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^ | + | <note warning>Ce cours n'est plus à jour, il est préférable de ne pas le suivre. Je vous recommande le cours sur Zeste de Savoir : https://zestedesavoir.com/tutoriels/822/la-programmation-en-c-moderne/.</note> |
- | + | ||
- | ====== La programmation orientée objet ====== | + | |
- | + | ||
- | Deux aspect : structurer les données et leur appliquer des traitements. Dans les chapitres précédents, vu la partie traitement : l'algorithmique. La POO vise à fournir un méthode pour structurer les données. | + | |
- | + | ||
- | ===== Classe et objet ===== | + | |
- | + | ||
- | Classe = type définit dans le code, objet = ce qui apparaît en mémoire dans le code. objet est l'instanciation d'une classe. Il peut y avoir plusieurs objets qui sont instancier à partir d'une classe (on peut également créer une classe mais ne pas instancier d'objet, mais l'intérêt est limité). | + | |
- | + | ||
- | Déjà vu des exemples de classe : string, vector, array | + | |
- | + | ||
- | Une classe rassemble des variables et des fonctions. S'appellent variables membres ou attribues et fonctions membres ou méthodes. La syntaxe : | + | |
- | + | ||
- | <code> | + | |
- | class nom_de_la_classe { | + | |
- | // définitions des variables et fonctions | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | (attention au point-virgule après les crocher | + | |
- | + | ||
- | Pour utiliser une classe, comme un type (comme vous faites avec string depuis le début) : | + | |
- | + | ||
- | <code> | + | |
- | nom_de_la_classe nom_de_variable {}; | + | |
- | </code> | + | |
- | + | ||
- | Bien sûr, peut s'utiliser comme paramètre de fonctions ou template : | + | |
- | + | ||
- | <code> | + | |
- | class A {}; | + | |
- | + | ||
- | void f(A a) {} // fonction qui prend un objet de type A comme paramètre | + | |
- | A a; | + | |
- | f(a); | + | |
- | + | ||
- | A f() {} // fonction qui retourne un objet de type A | + | |
- | A a = f(); | + | |
- | auto a = f(); | + | |
- | + | ||
- | template<typename T> | + | |
- | void f() {} | + | |
- | + | ||
- | f<A>(); // type A comme argument template | + | |
- | </code> | + | |
- | + | ||
- | ===== Visibilité des membres d'une classe ===== | + | |
- | + | ||
- | 3 types de visibilité : | + | |
- | + | ||
- | * public (publique) : le membre est visible depuis l'extérieur de la classe ; | + | |
- | * private (privé) : le membre est n'est pas visible depuis l'extérieur de la classe ; | + | |
- | * protected (protégé) : le membre est visible que depuis les classes dérivées. | + | |
- | + | ||
- | Le troisième cas est lié à la notion d'héritage, sera vu dans les classes à sémantique d'entité. | + | |
- | + | ||
- | Par exemple, une classe A avec un membre f() ou i. Pour appeler le membre, on utilise l'opérateur . (comme déjà fait avec begin et end par exemple) : | + | |
- | + | ||
- | <code> | + | |
- | A a {}; // défini a | + | |
- | a.i = 0; // accès à membre i | + | |
- | a.f(); // accès à membre f() | + | |
- | </code> | + | |
- | + | ||
- | Bien faire attention aux notions de variables et types. A est un type, il permet de déclarer une variable. a est une variable, on peut appeler . dessus. | + | |
- | + | ||
- | Dans ce code, on utilise la classe A, on est l'extérieur de la classe. Comme on a accès aux membres, on a donc un accès publique. Avec un membre privé, essayer d'accéder depuis l'extérieur produit une erreur du compilateur : | + | |
- | + | ||
- | <code> | + | |
- | main.cpp:9:7: error: 'i' is a private member of 'A' | + | |
- | a.i = 123; | + | |
- | ^ | + | |
- | main.cpp:2:9: note: implicitly declared private here | + | |
- | int i {}; | + | |
- | ^ | + | |
- | main.cpp:10:7: error: 'f' is a private member of 'A' | + | |
- | a.f(); | + | |
- | ^ | + | |
- | main.cpp:3:10: note: implicitly declared private here | + | |
- | void f() {} | + | |
- | ^ | + | |
- | 2 errors generated. | + | |
- | </code> | + | |
- | + | ||
- | On défini la visibilité des membres en utilisant les mots-clés public, private et protected. Par exemple : | + | |
- | + | ||
- | <code> | + | |
- | class A { | + | |
- | public: | + | |
- | int i {}; | + | |
- | void foo() {} | + | |
- | private: | + | |
- | int j {}; | + | |
- | void g() {} | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | La déclaration de visibilité s'applique tant qu'un autre identificateur n'est pas spécfiiée. Donc dans ce code, i et f sont publique et j et g sont privé. | + | |
- | + | ||
- | <code> | + | |
- | A a {}; | + | |
- | a.i = 123; // ok | + | |
- | a.f(); // ok | + | |
- | a.j = 123; // erreur | + | |
- | a.g(); // erreur | + | |
- | </code> | + | |
- | + | ||
- | Par défaut, le mot-clé ''class'' créer une classe avec des membres en visibilité privée, on omettre le private s'il est en premier. Donc écrire : | + | |
- | + | ||
- | <code> | + | |
- | class A { | + | |
- | private: | + | |
- | int i {}; | + | |
- | void foo() {} | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | est équivalent à : | + | |
- | + | ||
- | <code> | + | |
- | class A { | + | |
- | int i {}; | + | |
- | void foo() {} | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | Le mot-clé struct est similaire à class et permet de définir une classe. La seule différence est que struct a une visibilité publique par défaut : | + | |
- | + | ||
- | <code> | + | |
- | class A { | + | |
- | int i {}; | + | |
- | }; | + | |
- | + | ||
- | struct B { | + | |
- | int i {}; | + | |
- | }; | + | |
- | + | ||
- | A a {}; | + | |
- | a.i = 123; // erreur, i est privé avec class si public n'est pas spécifié | + | |
- | + | ||
- | + | ||
- | B b {}; | + | |
- | b.i = 123; // ok, i est publique avec struct par défaut | + | |
- | </code> | + | |
- | + | ||
- | ===== Classe template ===== | + | |
- | + | ||
- | De la même manière que l'on a pu définir des fonctions template, il est possible de définir des classes template. Un exemple de classe template, c'est vector ou array. | + | |
- | + | ||
- | La déclaration d'un classe template est similaire à une fonction, il faut ajouter template avec la liste des paramètres tempalte : | + | |
- | + | ||
- | <code> | + | |
- | template<typename T> | + | |
- | class A { | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | Les paramètres template peuvent être utilisé dans l'ensemble de la classe, pour la déclaration d'une variable membre ou comme paramètre de fonction membre. | + | |
- | + | ||
- | <code> | + | |
- | template<typename T> | + | |
- | struct A { | + | |
- | T value {}; | + | |
- | T f(T param); | + | |
- | }; | + | |
- | </code> | + | |
- | + | ||
- | __ séparation implémentation et définition __ | + | |
- | + | ||
- | Pour instancier une classe template, il faut spécifier les arguments template. Contrairement aux fonctions template, le compilateur ne peut pas déduire les arguments template à partir des arguments de fonction. | + | |
- | + | ||
- | <code> | + | |
- | A<int> a_int {}; | + | |
- | A<double> a_double {}; | + | |
- | </code> | + | |
- | + | ||
- | ^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^ | + | |
- | + | ||
- | {{tag> Cours C++}} | + |