Fiche de révision : Programmation orientée objet en C++

📋 Plan du Cours

1. Fondements et qualité de la conception objet
2. De la programmation procédurale à la POO
3. Concepts fondamentaux de la POO
4. Classes, objets et méthodes C++
5. Encapsulation et visibilité
6. Constructeurs et destructeurs
7. Généricité et patrons C++
8. Patrons de classes et fonctions
9. Fonctions et classes amies
10. Surcharge des opérateurs
11. Héritage et contrôle des accès
12. Polymorphisme et fonctions virtuelles
13. Gestion des exceptions
14. Lancement et interception des exceptions
15. Propagation et traitement des erreurs
16. Hiérarchie des exceptions standard

📖 1. Fondements et qualité de la conception objet

🔑 Notions clés & Définitions

• Validité : le fait qu’un logiciel effectue exactement les tâches pour lesquelles il a été conçu
• Extensibilité : la capacité d’un logiciel à intégrer facilement de nouvelles spécifications
• Modularité : organiser un logiciel autour de modules, qui sont des entités indépendantes intégrées dans une architecture
• Réutilisabilité : la possibilité de réutiliser complètement ou partiellement un logiciel

📝 Points essentiels

• La maintenance représente environ 70 % du coût total d’un logiciel.

💡 Astuce mémo

Maintenance coûteuse → besoin de qualité, modularité et réutilisation

📖 2. De la programmation procédurale à la POO

🔑 Notions clés & Définitions

• Objet : une entité associant des données et des fonctions, appelées méthodes, qui opèrent sur ces données

★ À maîtriser

📌 La programmation procédurale découpe un programme en fonctions qui réalisent des traitements particuliers, tandis que la programmation orientée objet le considère comme un ensemble d’objets collaborant par messages.

📌 Dans l’approche procédurale, les fonctions peuvent agir sur les mêmes données, ce qui crée un risque de partage de données et d’écritures simultanées dans un même fichier.

Compléments

• Les langages cités comme procéduraux sont C, Pascal et Fortran.

💡 Astuce mémo

Procédural : données séparées des fonctions ; objet : données et méthodes réunies

📖 3. Concepts fondamentaux de la POO

🔑 Notions clés & Définitions

• Encapsulation : distingue l’interface d’un objet, qui décrit ce qu’il fait, de son implémentation, qui définit comment il le réalise
• Classe : regroupe les objets ayant les mêmes propriétés et le même comportement
• Instance : un objet appartenant à une classe
• Polymorphisme : permet à des objets de classes dérivées d’une même classe de répondre au même message
• Héritage : définir une nouvelle classe à partir d’une classe existante en lui ajoutant des propriétés ou des méthodes

📝 Points essentiels

• Les objets communiquent entre eux par des messages, par lesquels un objet demande un service à un autre objet.

💡 Astuce mémo

EACI : Encapsulation, Abstraction, Classification, Identité

📖 4. Classes, objets et méthodes C++

🔑 Notions clés & Définitions

• Objet : une entité individuelle et identifiable, réelle ou abstraite, caractérisée par une identité, un état et un comportement
• Classe : un modèle permettant de générer des objets partageant des attributs et des méthodes communes

★ À maîtriser

📌 En C++, une classe se déclare avec le mot-clé class, ses membres entre accolades et un point-virgule final.

📌 L’opérateur de résolution de portée :: permet de définir à l’extérieur de la classe une méthode appartenant à cette classe.

Compléments

• Dans la classe Point de l’exemple, x et y sont des attributs, tandis que afficher, placer et deplace sont des méthodes.

📌 Le passage d’un objet par référence évite la duplication de l’objet lors de son utilisation comme paramètre d’une méthode.

💡 Astuce mémo

Une classe sert de moule pour fabriquer des objets partageant attributs et méthodes

📖 5. Encapsulation et visibilité

🔑 Notions clés & Définitions

• Encapsulation : sépare les aspects externes publics d’un objet de ses détails internes privés afin de pouvoir modifier l’implémentation sans affecter les applications qui utilisent l’objet

• Accesseur : une méthode de lecture d’un attribut privé, généralement nommée get suivie du nom de l’attribut

• Mutateur : une méthode de modification d’un attribut, généralement nommée set suivie du nom de l’attribut

📝 Points essentiels

📌 En C++, public rend les membres accessibles dans toute l’application, protected les rend accessibles à la classe et à ses classes dérivées, et private les réserve aux fonctions membres de la classe.

• En C++, les membres d’une classe sont privés par défaut.

💡 Astuce mémo

Public est accessible partout, protected aux classes liées, private à la classe

📖 6. Constructeurs et destructeurs

🔑 Notions clés & Définitions

• Constructeur : une fonction membre spéciale qui initialise un objet, porte le nom de la classe, ne possède pas de type de retour et est appelée lors de la déclaration de l’objet
• Constructeur par recopie : un constructeur qui initialise un objet à partir du contenu d’un autre objet de la même classe et reçoit ce dernier par référence
• Destructeur : une méthode sans type de retour ni paramètre, appelée automatiquement lorsqu’une instance de la classe est détruite et identifiée par le nom de la classe précédé de ~

★ À maîtriser

📌 Un constructeur sans paramètre ou dont tous les paramètres ont des valeurs par défaut est un constructeur par défaut.

Compléments

• Lorsqu’un tableau d’objets est déclaré, le constructeur par défaut est appelé autant de fois que la taille du tableau.

💡 Astuce mémo

Construire → utiliser → détruire

📖 7. Généricité et patrons C++

🔑 Notions clés & Définitions

• Généricité : permet de paramétrer des fonctions et des classes par un ou plusieurs types de données afin de produire du code réutilisable
• Patron de fonction : une définition générique qui est instanciée par le compilateur pour produire une fonction adaptée au type utilisé
• Patron de classe : une définition de classe paramétrée par un type de données, permettant de créer plusieurs classes similaires sans réécrire leur définition

📝 Points essentiels

📐 Formule — La syntaxe d’un patron de fonction générique est $\text{template} <\text{class } T>$ suivie d’une fonction utilisant le type T.

• La déclaration point<int> a instancie un patron de classe point avec le type int, tandis que point<float> ad l’instancie avec le type float.

💡 Astuce mémo

Un patron template agit comme un moule adaptable à plusieurs types

📖 8. Patrons de classes et fonctions

🔑 Notions clés & Définitions

• Patron de classe : Permet de définir une classe générique paramétrée par un ou plusieurs types.

★ À maîtriser

• Le patron point<T> peut être instancié avec int, char, double ou string, et ses méthodes utilisent alors le type choisi pour les coordonnées.

Compléments

• Un patron de classe peut comporter plusieurs paramètres de type, par exemple template<class A, class B, class C> class MaClasse.

• Dans la classe Etudiant<T,T1,T2>, T représente le nom et le prénom, T1 l’identifiant et T2 l’âge.

📖 9. Fonctions et classes amies

🔑 Notions clés & Définitions

• Fonction amie : Fonction extérieure à une classe autorisée à accéder à ses données privées comme une fonction membre.

★ À maîtriser

• La déclaration friend class B dans la classe A autorise les fonctions membres de B à accéder aux membres privés de A.

📌 Les déclarations d’amitié ne s’héritent pas : si f est amie de A et que B dérive de A, f n’est pas automatiquement amie de B.

Compléments

• Une fonction indépendante peut être déclarée amie d’une classe, comme coincide(point, point), qui compare les coordonnées privées de deux points.

💡 Astuce mémo

Amitié = accès privé accordé sans devenir fonction membre

📖 10. Surcharge des opérateurs

🔑 Notions clés & Définitions

• Surcharge d’opérateur : Consiste à définir une fonction donnant une signification à un opérateur existant pour des objets d’une classe.

★ À maîtriser

📌 Un opérateur ne peut être surchargé que dans un contexte où il possède au moins un argument de type classe.

📌 Pour deux objets point a et b, une surcharge membre s’écrit point operator+(point) et s’utilise comme a.operator+(b), tandis qu’une surcharge amie s’écrit point operator+(point, point).

Compléments

• La pluralité de l’opérateur doit être conservée : les opérateurs unaires comme ++ et -- restent unaires, tandis que les opérateurs binaires comme +, -, * et / restent binaires.

💡 Astuce mémo

Fonction membre : a.operator+(b) ; fonction amie : operator+(a,b)

📖 11. Héritage et contrôle des accès

🔑 Notions clés & Définitions

• Héritage simple : Mécanisme par lequel une classe dérivée hérite des attributs et des méthodes d’une seule classe mère.

★ À maîtriser

📌 En C++, si aucun mode n’est indiqué dans la déclaration de l’héritage, l’héritage est privé.

📌 En dérivation publique, les membres publics de la classe de base restent publics, les membres protégés deviennent protégés et les membres privés restent inaccessibles dans la classe dérivée.

• Lors de la création d’un objet dérivé, C++ alloue la mémoire, prépare le constructeur dérivé, exécute le constructeur de base, puis exécute le constructeur dérivé.

Compléments

📌 Lorsqu’un constructeur de la classe mère doit être appelé, le constructeur de la classe dérivée le spécifie dans sa liste d’initialisation, par exemple Pointcolor(int a,int b,int c):Point(a,b).

💡 Astuce mémo

Base → dérivée → héritage multiple → constructeurs

📖 12. Polymorphisme et fonctions virtuelles

🔑 Notions clés & Définitions

• Polymorphisme : Consiste à définir des fonctions de même nom dans une classe de base et ses classes dérivées, avec un comportement différent pour un même appel.
• Fonction virtuelle pure : Fonction virtuelle déclarée avec =0, sans implémentation imposée dans la classe de base.

📝 Points essentiels

• Une fonction virtuelle déclarée dans la classe générale permet de sélectionner, à l’exécution, la version correspondant au type exact de l’objet pointé.

• Un destructeur virtuel garantit que, lorsqu’un pointeur de base référence un objet dérivé, le destructeur de la classe dérivée est appelé avant celui de la classe de base.

• Une classe comportant au moins une fonction virtuelle pure est abstraite et il est impossible d’instancier directement un objet de cette classe.

💡 Astuce mémo

virtual → choix à l’exécution → comportement polymorphe

📖 13. Gestion des exceptions

🔑 Notions clés & Définitions

• Exception : Interruption de l’exécution d’un programme à la suite d’un événement particulier, puis transfert du contrôle à un gestionnaire.

★ À maîtriser

• En C++, une exception est placée dans un bloc try, lancée avec throw, puis interceptée par un gestionnaire catch correspondant.

📌 Le type du paramètre transmis à throw détermine le type de l’exception levée et le gestionnaire catch correspondant.

Compléments

📌 Le gestionnaire catch(...) est un gestionnaire universel qui peut intercepter les exceptions non traitées par les autres blocs catch et se place normalement à la fin.

💡 Astuce mémo

try → throw → catch

📖 14. Lancement et interception des exceptions

★ À maîtriser

• Le mot-clé throw lance une exception en transmettant un paramètre e, dont le type détermine le type de l’exception levée.

• Un gestionnaire catch placé après un bloc try intercepte une exception lorsque le type de son argument correspond au type de l’exception levée.

• Lorsque plusieurs gestionnaires suivent un bloc try, le premier gestionnaire dont le type d’argument correspond à l’exception levée est exécuté.

Compléments

📌 Le gestionnaire catch(...) est un gestionnaire universel qui peut intercepter toute exception et qui est normalement placé en dernier.

• Dans l’exemple présenté, les exceptions de type erreur, int et char sont traitées par des gestionnaires spécifiques, tandis qu’une exception de type float est prise en charge par catch(...).

💡 Astuce mémo

throw → try → catch

📖 15. Propagation et traitement des erreurs

★ À maîtriser

• Lorsqu’une division d’un complexe par un flottant nul est demandée, l’opérateur /= lance une exception, celle-ci remonte dans la pile d’appels jusqu’à un gestionnaire catch, puis le gestionnaire affiche l’erreur ou demande une nouvelle valeur.

📌 Le traitement d’une exception peut être placé dans main ou dans une fonction intermédiaire comme input_et_divise, tandis que la fonction qui détecte l’erreur conserve le même throw.

Compléments

• Dans la première version, l’opérateur /= lance la chaîne "division par zéro" sous la forme d’un const char* et la fonction main l’intercepte puis l’affiche.

• Une boucle do while permet de redemander un diviseur jusqu’à ce que celui-ci soit différent de zéro, en quittant la boucle avec break après une division réussie.

💡 Astuce mémo

Division par zéro → exception → correction ou arrêt

📖 16. Hiérarchie des exceptions standard

🔑 Notions clés & Définitions

• exception : La classe de base dont dérivent les exceptions standard et qui fournit la méthode what() renvoyant le message d’erreur encapsulé.
• domain_error : Une erreur de domaine mathématique, par exemple une division par zéro, et qui dérive de logic_error.

★ À maîtriser

📌 Les exceptions runtime_error signalent des erreurs difficiles à éviter à l’exécution, tandis que les exceptions logic_error signalent des erreurs de logique interne qui devraient être évitables.

📌 Pour traiter une exception standard tout en conservant son type réel et la bonne version de what(), il est recommandé de la capturer par const exception&.

Compléments

• La hiérarchie comprend notamment: bad_alloc : problème d’allocation mémoire, ios_base::failure : problème d’entrées-sorties, range_error : valeur retournée incorrecte lors d’un calcul interne, overflow_error : nombre trop grand lors d’un calcul, underflow_error : nombre trop proche de zéro lors d’un calcul

• La hiérarchie logic_error comprend:

  • domain_error : erreur de domaine
  • invalid_argument : mauvais argument passé à une fonction
  • length_error : objet trop grand pour le système
  • out_of_range : valeur hors limites

📌 Une exception personnalisée doit de préférence dériver de la classe exception afin de permettre un traitement hiérarchisé par des gestionnaires spécialisés ou génériques.

💡 Astuce mémo

domain_error pour une erreur ciblée, exception pour un traitement général

📊 Tableaux de synthèse

Niveaux de visibilité C++

Modes de dérivation et accessibilité