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 = 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 :

class nom_de_la_classe {
    // définitions des variables et fonctions
};

(attention au point-virgule après les crocher

Pour utiliser une classe, comme un type (comme vous faites avec string depuis le début) :

nom_de_la_classe nom_de_variable {};

Bien sûr, peut s'utiliser comme paramètre de fonctions ou template :

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

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) :

A a {};  // défini a
a.i = 0; // accès à membre i
a.f();   // accès à membre f()

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 :

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.

On défini la visibilité des membres en utilisant les mots-clés public, private et protected. Par exemple :

class A {
public:
    int i {};
    void foo() {}
private:
    int j {};
    void g() {}
};

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é.

A a {};
a.i = 123; // ok
a.f();     // ok
a.j = 123; // erreur
a.g();     // erreur

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 :

class A {
private:
    int i {};
    void foo() {}
};

est équivalent à :

class A {
    int i {};
    void foo() {}
};

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 :

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

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 :

template<typename T>
class A {
};

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.

template<typename T>
struct A {
    T value {};
    T f(T param);
};

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.

A<int> a_int {};
A<double> a_double {};