Ficha de revisão: Programmation Orientée Objet en C++

📋 Plan du Cours

1. Encapsulation en C++
2. Classes et membres
3. Contrôle d'accès
4. Structures et unions
5. Héritage multiple
6. Polymorphisme et virtuals
7. Gestion des exceptions
8. Généricité et templates
9. Flux d'entrée/sortie
10. Surcharge d'opérateurs

📖 1. Encapsulation en C++

🔑 Notions clés & Définitions

• Encapsulation : Technique de programmation orientée objet consistant à regrouper données et fonctions qui manipulent ces données dans une même unité, appelée classe, afin de protéger l'intégrité des données et de définir une interface claire.
• Classe : Structure définie par le mot-clé class, regroupant des données membres (attributs) et des fonctions membres (méthodes). Elle sert de modèle pour créer des objets.
• Objet : Instance concrète d'une classe, représentant une entité avec ses propres valeurs pour les données membres.
• Données membres : Variables déclarées dans une classe, représentant l'état d'un objet. Leur accès est contrôlé par des mots-clés (private, protected, public).
• Fonctions membres : Méthodes associées à une classe, permettant d'interagir avec ses données membres. Elles définissent l'interface d'accès et de modification.
• Contrôle d'accès : Mécanisme permettant de définir la visibilité des membres d'une classe (private, protected, public) pour assurer l'encapsulation.

📝 Points essentiels

• L'encapsulation repose sur la déclaration des données membres en private pour empêcher leur accès direct depuis l'extérieur.
• Les fonctions membres déclarées en public servent d'interface pour manipuler les données, garantissant leur intégrité.
• La syntaxe d'une classe inclut des sections private, protected, et public, permettant de contrôler l'accès aux membres.
• La déclaration d'une instance (objet) se fait en utilisant le nom de la classe suivi du nom de l'objet.
• La modularité et l'indépendance des composants sont renforcées par l'encapsulation, facilitant la maintenance et l'évolution du code.
• Les fonctions membres peuvent être déclarées inline pour optimiser les performances en évitant les appels de fonction.

💡 À retenir

L'encapsulation en C++ consiste à regrouper données et fonctions dans une classe en contrôlant leur accès, ce qui favorise la sécurité, la modularité et la maintenance du code orienté objet.

📖 2. Classes et membres

🔑 Notions clés & Définitions

• Classe : Structure définissant un type personnalisé regroupant des données membres (attributs) et des fonctions membres (méthodes). Elle sert de modèle pour créer des objets.
• Objet : Instance concrète d'une classe, représentant une entité avec ses propres données membres.
• Données membres : Variables déclarées dans une classe, représentant l’état d’un objet.
• Fonctions membres : Méthodes associées à une classe, permettant d’interagir avec ses données membres.
• Encapsulation : Technique consistant à cacher les données membres d’une classe et à n’y accéder que via des fonctions membres publiques.
• Contrôle d’accès : Mots-clés (private, protected, public) déterminant la visibilité et l’accessibilité des membres d’une classe.

📝 Points essentiels

• La déclaration d’une classe commence par le mot-clé class suivi du nom de la classe, puis d’un bloc { ... }.
• Par défaut, les membres d’une classe sont private, sauf indication contraire.
• La syntaxe pour contrôler l’accès :

  class Exemple {
  private:
      int data; // inaccessible depuis l’extérieur
  public:
      void setData(int d) { data = d; } // accessible publiquement
      int getData() { return data; }
  };
  

• Les données membres doivent être déclarées en privé pour garantir l’abstraction.
• Les fonctions membres peuvent accéder à toutes les données membres, indépendamment de leur niveau d’accès.
• La déclaration d’un objet :

  Exemple obj;
  obj.setData(10);
  

• La notion de membre statique : variable partagée par toutes les instances de la classe, déclarée avec static.
• La déclaration de fonctions membres peut se faire inline (dans la classe) ou hors classe avec la syntaxe NomClasse::NomFonction.
• Les fonctions amies (friend) permettent à des fonctions externes d’accéder aux membres privés d’une classe, mais leur usage doit être limité.

💡 À retenir

Une classe en C++ sert de modèle pour créer des objets en regroupant données et fonctions, tout en assurant l’encapsulation pour protéger l’intégrité des données. La maîtrise du contrôle d’accès et des membres (statiques, fonctions inline, amies) est essentielle pour une programmation orientée objet efficace.

📖 3. Contrôle d'accès

🔑 Notions clés & Définitions

• Classe : Structure en C++ regroupant des données membres (attributs) et des fonctions membres (méthodes). Elle définit un type personnalisé.
• Objet : Instance concrète d'une classe, représentant une entité avec ses propres valeurs pour les données membres.
• Membres privés (private) : Données ou fonctions accessibles uniquement à l'intérieur de la classe. Utilisés pour l'encapsulation et la protection des données.
• Membres publics (public) : Données ou fonctions accessibles depuis l'extérieur de la classe. Permettent d'interagir avec l'objet.
• Membres protégés (protected) : Données ou fonctions accessibles dans la classe et ses dérivées. Utilisés pour l'héritage.
• Encapsulation : Technique consistant à cacher les données membres d'une classe et à n'y accéder qu'à travers des méthodes publiques, assurant la sécurité et l'intégrité des données.

📝 Points essentiels

• Par défaut, dans une classe C++, les membres sont privés.
• La déclaration des membres avec private, protected, ou public permet de contrôler leur accès.
• L'encapsulation garantit que les données ne peuvent être modifiées directement depuis l'extérieur, mais uniquement via des méthodes publiques.
• La déclaration des membres dans l'ordre private, puis protected, puis public est recommandée pour la lisibilité.
• Les fonctions membres publiques servent d'interface pour manipuler les données privées.
• Les fonctions amies (friend) permettent à des fonctions externes d’accéder aux membres privés, mais leur usage doit être limité pour préserver la POO.
• La modularité et la sécurité du code sont renforcées par le contrôle d'accès.

💡 À retenir

Le contrôle d'accès en C++, via private, protected, et public, est essentiel pour assurer l'encapsulation, permettant de protéger les données et de définir une interface claire entre la classe et le reste du programme.

📖 4. Structures et unions

🔑 Notions clés & Définitions

• Structure (struct) : Un type de donnée composite permettant de regrouper plusieurs variables (membres) de types différents sous un seul nom. Elle sert à représenter des objets complexes avec plusieurs attributs.

• Union : Un type de donnée similaire à la structure, mais dont tous les membres partagent la même zone mémoire. Elle permet de stocker différentes données à des moments différents, optimisant l'utilisation de la mémoire.

• Membres : Les variables ou fonctions déclarées à l’intérieur d’une structure ou union. Les membres peuvent être de différents types.

• Encapsulation : Technique consistant à limiter l’accès direct aux membres d’une structure ou union, généralement via des méthodes publiques ou des contrôles d’accès (private, protected, public).

• Mots-clés : struct pour définir une structure, union pour définir une union.

📝 Points essentiels

• Déclaration d’une structure :

  struct NomStructure {
      type membre1;
      type membre2;
      // autres membres
  };
  

• Déclaration d’une union :

  union NomUnion {
      type membre1;
      type membre2;
      // autres membres
  };
  

• Différence principale :

  • Structure : chaque membre possède sa propre zone mémoire.
  • Union : tous les membres partagent la même zone mémoire, la taille de l’union étant celle de son membre le plus grand.

• Utilisation :

  • Structures pour représenter des objets complexes avec plusieurs attributs.
  • Unions pour économiser de la mémoire lorsque différentes données ne seront pas utilisées simultanément.

• Accès aux membres :
  Utilisation du point (.) pour accéder aux membres d’une instance.
  Exemple : monStruct.membre1.

• Contrôle d’accès :
  Par défaut, tous les membres d’une structure sont publics. Il est possible d’utiliser private, protected, ou public pour contrôler l’accès.

• Taille :

  • La taille d’une structure est la somme des tailles de ses membres, éventuellement avec un alignement.
  • La taille d’une union est celle de son membre le plus grand.

💡 À retenir

Les structures permettent de modéliser des objets complexes avec plusieurs attributs, tandis que les unions optimisent l’utilisation mémoire en partageant l’espace entre plusieurs membres, mais à un moment donné, un seul membre peut être utilisé.

📖 5. Héritage multiple

🔑 Notions clés & Définitions

• Héritage multiple : Mécanisme en programmation orientée objet permettant à une classe (dérivée) d'hériter de plusieurs classes (de base) simultanément, combinant leurs attributs et méthodes.
• Classe de base : Classe dont une ou plusieurs classes dérivées héritent.
• Classe dérivée : Classe qui hérite de plusieurs classes de base, pouvant accéder à leurs membres publics et protégés.
• Ambiguïté : Problème pouvant survenir lorsque deux classes de base possèdent une méthode ou un attribut portant le même nom, nécessitant des précisions pour l'accès.
• Résolution d'ambiguïté : Utilisation de la syntaxe NomClasse::membre pour préciser la classe dont on veut accéder au membre hérité.

📝 Points essentiels

• L'héritage multiple permet de réutiliser et combiner plusieurs comportements dans une seule classe, favorisant la flexibilité.
• En C++, une classe peut hériter de plusieurs classes en les listant dans la déclaration de classe, séparées par des virgules :

  class Derived : public Base1, public Base2 { ... };
  

• La visibilité des membres hérités dépend du mode d'héritage (public, protected, private) spécifié lors de la déclaration.
• La résolution des ambiguïtés peut nécessiter l'utilisation de la syntaxe Base1::membre pour préciser le membre hérité.
• La gestion des constructeurs, destructeurs et opérateurs doit être adaptée dans le contexte de l'héritage multiple pour éviter les conflits ou la duplication.

💡 À retenir

L'héritage multiple en C++ offre une grande puissance de composition, mais doit être utilisé avec précaution pour éviter les ambiguïtés et complexités. La résolution claire des conflits et une conception soignée sont essentielles pour exploiter efficacement cette fonctionnalité.

📖 6. Polymorphisme et virtuals

🔑 Notions clés & Définitions

• Polymorphisme : Capacité d’un langage orienté objet à traiter des objets de différentes classes par le biais d’une interface commune, permettant d’appeler des méthodes spécifiques à chaque classe via des pointeurs ou références de la classe de base.
• Méthode virtuelle : Fonction membre déclarée avec le mot-clé virtual dans une classe de base, permettant la redéfinition dans une classe dérivée et assurant le comportement dynamique (liaison tardive).
• Liaison dynamique (ou liaison tardive) : Processus par lequel l’appel d’une méthode virtuelle est résolu au moment de l’exécution en fonction du type réel de l’objet pointé, permettant le polymorphisme.
• Classe abstraite : Classe contenant au moins une méthode virtuelle pure (déclarée avec = 0), ne pouvant pas être instanciée directement, mais servant de base pour d’autres classes.
• Redéfinition : Processus par lequel une classe dérivée fournit sa propre version d’une méthode virtuelle déclarée dans la classe de base.
• Vtable (table de virtual) : Structure interne utilisée par le compilateur pour gérer la liaison dynamique des méthodes virtuelles, associant chaque classe à une table de pointeurs vers ses méthodes virtuelles.

📝 Points essentiels

• La déclaration d’une méthode comme virtual dans une classe de base permet la redéfinition dans les classes dérivées.
• Lorsqu’on utilise un pointeur ou une référence à une classe de base pour manipuler un objet d’une classe dérivée, l’appel d’une méthode virtuelle exécute la version la plus spécifique (de la classe dérivée), grâce à la liaison dynamique.
• La présence d’une méthode virtuelle dans une classe rend cette classe abstraite si elle possède au moins une méthode virtuelle pure (= 0).
• La redéfinition d’une méthode virtuelle doit respecter la même signature que dans la classe de base.
• La destruction d’une classe de base doit être déclarée virtuelle (virtual ~ClasseBase()) pour assurer une destruction correcte des objets dérivés.
• Le polymorphisme permet de concevoir des programmes extensibles et modulaires, en traitant différents objets via une interface commune.

💡 À retenir

Le polymorphisme en C++ repose sur l’utilisation de méthodes virtuelles, permettant d’appeler la version la plus spécifique d’une méthode selon le type réel de l’objet, ce qui facilite la conception de systèmes extensibles et dynamiques. La liaison dynamique est essentielle pour assurer ce comportement, notamment dans le cas des classes abstraites et des méthodes virtuelles pures.

📖 7. Gestion des exceptions

🔑 Notions clés & Définitions

• Exception : Événement anormal ou inattendu qui survient lors de l'exécution d'un programme, pouvant interrompre son déroulement normal.
• Gestion des exceptions : Technique permettant de détecter, capturer et traiter ces événements pour assurer la robustesse et la stabilité du programme.
• Try-catch : Structure en C++ utilisée pour entourer le code susceptible de générer une exception (try) et pour définir le traitement à effectuer en cas d'exception (catch).
• Throw : Instruction permettant de déclencher une exception en la lançant explicitement.
• Exception spécifique : Objet ou type particulier utilisé pour représenter une erreur ou un événement exceptionnel précis.
• Propagation d'exception : Processus par lequel une exception non capturée dans un bloc try est transférée vers un bloc supérieur ou vers le gestionnaire global.

📝 Points essentiels

• La gestion des exceptions en C++ repose sur les mots-clés try, catch et throw.
• Lorsqu'une erreur survient, une exception peut être levée avec throw, puis capturée par un bloc catch correspondant.
• Il est possible de définir plusieurs blocs catch pour traiter différents types d'exceptions.
• La déclaration d'une exception peut se faire avec des objets de classes personnalisées, permettant une gestion fine et spécifique.
• La propagation d'une exception non capturée peut entraîner la terminaison du programme, sauf si une gestion globale est mise en place.
• La pratique recommandée est d'utiliser la gestion d'exceptions pour traiter les erreurs évitables et maintenir la stabilité du programme.

💡 À retenir

La gestion des exceptions en C++ permet de rendre les programmes plus robustes en capturant et traitant efficacement les erreurs inattendues, évitant ainsi leur propagation non contrôlée et la terminaison brutale du programme.

📖 8. Généricité et templates

🔑 Notions clés & Définitions

• Généricité : Capacité d'écrire du code qui fonctionne avec différents types de données sans duplication, favorisant la réutilisation et la modularité.
• Template (modèle) : Structure de programmation en C++ permettant de définir des classes ou fonctions génériques, paramétrées par des types.
• Template de classe : Modèle permettant de créer des classes paramétrées par un ou plusieurs types, par exemple template <typename T> class MaClasse.
• Template de fonction : Fonction générique pouvant s'appliquer à différents types, par exemple template <typename T> T max(T a, T b).
• Instantiation (instanciation) : Création concrète d'une classe ou fonction à partir d'un template en spécifiant un type particulier.
• Spécialisation : Définition spécifique d’un template pour un type particulier, permettant d’adapter le comportement.

📝 Points essentiels

• Les templates permettent d’écrire du code réutilisable, évitant la duplication pour différents types.
• La syntaxe de déclaration d’un template de classe :

  template <typename T>
  class NomClasse {
      T membre;
      // autres membres
  };
  

• La syntaxe pour un template de fonction :

  template <typename T>
  T fonction(T a, T b) {
      return (a > b) ? a : b;
  }
  

• Lors de l’utilisation, le compilateur instancie automatiquement le template avec le type fourni :

  int x = max<int>(3, 5);
  double y = max<double>(2.5, 3.7);
  

• La spécialisation permet d’adapter le comportement d’un template pour un type spécifique, par exemple pour char.

💡 À retenir

Les templates en C++ sont essentiels pour la programmation générique, permettant d’écrire du code flexible, réutilisable et efficace, en différenciant la logique du type de données manipulé.

📖 9. Flux d'entrée/sortie

🔑 Notions clés & Définitions

• Flux d'entrée (cin) : Objet permettant la lecture de données depuis la console ou une source d'entrée. Exemple : cin >> variable;.
• Flux de sortie (cout) : Objet permettant l'affichage de données vers la console ou une destination de sortie. Exemple : cout << "Message";.
• Manipulateurs : Fonctions ou objets modifiant le comportement des flux, comme endl (fin de ligne), setw (largeur d'affichage), etc.
• Opérateur d'insertion (<<) : Utilisé pour envoyer des données vers un flux de sortie.
• Opérateur d'extraction (>>) : Utilisé pour lire des données depuis un flux d'entrée.
• Formatage : Techniques pour contrôler l'affichage (espaces, précision, alignement) lors de l'utilisation des flux.

📝 Points essentiels

• La bibliothèque <iostream> fournit les objets cin et cout pour gérer les flux d'entrée et de sortie.
• La syntaxe de base pour la lecture : cin >> variable;.
• La syntaxe de base pour l'écriture : cout << "texte" << variable;.
• Les manipulateurs comme endl insèrent une nouvelle ligne et flushent le buffer.
• La surcharge des opérateurs << et >> permet la création de flux personnalisés pour des classes utilisateur.
• La gestion du formatage (largeur, précision) se fait via des manipulateurs ou la fonction setprecision.

💡 À retenir

Les flux cin et cout en C++ permettent une gestion simple et efficace de l'entrée et de la sortie, en utilisant des opérateurs surchargés pour une syntaxe intuitive, tout en offrant des possibilités avancées de formatage et de personnalisation.

📖 10. Surcharge d'opérateurs

🔑 Notions clés & Définitions

• Surcharge d'opérateurs : Technique permettant de définir ou de redéfinir le comportement d’un opérateur pour des types de données utilisateur (classes ou structures). Elle permet d’utiliser des opérateurs standards (+, -, *, /, etc.) avec des objets de classes personnalisées.
• Operator overloading : Expression anglaise désignant la surcharge d’opérateurs en C++. Elle consiste à définir une fonction membre ou non membre qui remplace l’opération par une opération spécifique à la classe.
• Fonction membre de surcharge : Fonction définie dans la classe, permettant de redéfinir le comportement d’un opérateur pour les objets de cette classe.
• Fonction non membre (friend ou autre) : Fonction externe à la classe, déclarée amie (friend), qui peut accéder aux membres privés/protégés pour réaliser la surcharge.
• Operator : Mot-clé utilisé pour définir ou redéfinir un opérateur dans une classe.

📝 Points essentiels

• La surcharge d’opérateurs facilite la manipulation d’objets en leur permettant d’utiliser une syntaxe intuitive, comme si ces objets étaient des types primitifs.
• La syntaxe consiste à définir une fonction spécifique avec le mot-clé operator suivi du symbole de l’opérateur à surcharge (ex : operator+, operator[], operator()).
• La surcharge peut être effectuée en tant que fonction membre ou fonction amie (friend), selon l’opérateur et le contexte.
• Certains opérateurs ne peuvent pas être surchargés (ex : ::, sizeof, ?:, .).
• La surcharge doit respecter la sémantique de l’opérateur original pour éviter la confusion.
• Exemple : surcharge de l’opérateur + pour additionner deux objets d’une classe Complexe.

💡 À retenir

La surcharge d’opérateurs en C++ permet d’étendre la syntaxe du langage pour manipuler des objets personnalisés de manière naturelle, mais doit être utilisée avec précaution pour préserver la lisibilité et la cohérence du code.

📊 Tableaux de Synthèse

Aspect	Classes et membres	Contrôle d'accès
Définition	Modèle pour créer des objets avec données et méthodes	Mécanismes pour limiter la visibilité des membres
Mots-clés principaux	class, private, protected, public	private, protected, public
Par défaut	Membres privés dans une classe	Membres privés par défaut
Accès depuis l'extérieur	Via méthodes publiques	Selon le mot-clé (private, protected, public)
Membres statiques	Variables partagées par toutes les instances	Même principe, contrôlé par static
Fonctions inline	Définies dans la classe ou hors classe avec ::	N/A

Aspect	Structures et unions
Définition	Types de données composites, regroupant plusieurs membres
Mots-clés principaux	struct, union
Différence principale	Structure : membres ont leur propre mémoire; Union : partage mémoire
Utilisation	Structures : objets complexes; Unions : mémoire optimisée

⚠️ Pièges & Confusions Fréquentes

1. Confondre struct et class : en C++, struct et class sont similaires, seule la visibilité par défaut diffère (public pour struct, private pour class).
2. Oublier que les membres d'une classe sont privés par défaut si non spécifié.
3. Utiliser une union pour stocker différents types simultanément, sans gestion de la durée de vie ou de la validité des données.
4. Accéder directement aux membres privés d'une classe sans passer par des méthodes publiques ou amies.
5. Déclarer des membres statiques sans initialisation correcte.
6. Confondre protected (accessible en héritage) et private.
7. Déclarer une structure ou union sans préciser le type de ses membres, menant à des erreurs de syntaxe.

✅ Checklist Examen

• Maîtriser la différence entre classe et structure.
• Savoir déclarer et utiliser une classe avec ses membres privés, protégés, et publics.
• Comprendre le rôle du contrôle d'accès et ses implications.
• Savoir créer et manipuler des objets à partir d'une classe.
• Connaître la syntaxe pour déclarer des membres statiques, inline, et amis.
• Différencier structure et union, et connaître leur utilisation.
• Être capable d'identifier et éviter les pièges liés à l'encapsulation et au contrôle d'accès.
• Savoir utiliser les mots-clés struct et union correctement.
• Comprendre la mémoire partagée dans une union.
• Vérifier la maîtrise du vocabulaire spécifique : classe, objet, membre, encapsulation, héritage, polymorphisme, exception, template, flux, surcharge.
• Vérifier la compréhension des mécanismes d'héritage multiple.
• Savoir utiliser les virtuals et le polymorphisme.
• Être capable d'écrire une gestion d'exception simple.
• Maîtriser la surcharge d'opérateurs.
• Vérifier la capacité à utiliser les flux d'entrée/sortie (cin, cout) dans un contexte orienté objet.