Programmation :

du C au C++
Patrick Bonnin
Formation Continue
CONTINENTAL Rambouillet
 Objectifs de la Formation

• Comprendre les Concepts de la P.O.O :

 Notamment l’Encapsulation et l’Héritage,
• Comprendre leur Utilisation :
 Meilleure Structuration, Réutilisabilité des Développements,
• Comprendre leur Implémentation en C++:
 De la théorie, à la Pratique !
• Comprendre les Nouvelles Possibilités du C++ :
 Plus grande Efficacité des Développements.
• Etre Capable de Développer dans un Environnement C++:
 Classique : DevCpp, Visual (Microsoft), Buider C++
(Borland), environnement fenêtrés Windows / Linux
 Spécifique : RTMaps etc …
• Maquette Pédagogique ISTY:
 Module MT2 : CM/TD : 13h, TP : 3 x 4h,
 Eléments en + : Patrons, Exceptions …
 Plan

1. Introduction:
2. Du C au C++:
3. La Notion de Classe:
4. Héritage et Polymorphisme:
5. Gestion des Exceptions:
 Introduction

1. Historique:
2. Eléments de Qualité Logicielle :
3. Rappels du Langage C:
 Historique
• Système UNIX : 1969 : Ken Thompson, Dennis Ritchie,
 En Langage d’Assemblage,
• Langage C : 1972 : Dennis Ritchie, Brian Kerninghan.
 Inspiré du langage B (structure de contrôle),
• Unix est réécrit en Langage C en 1973 :
 À 90 % : le C est « proche » de la machine!
• Concept de la Programmation Orienté Objet :
 Simula (1962), Smaltalk (1979),
• C++ : 1982 : Bjarne Stroustrup :
 Adjoindre au Langage C des fonctionnalités permettant
d’appliquer les Concepts de la Programmation Orientée
Objet => Conserve la puissance du Langage C !!!
• Java : 1995 : Sun Micro Systems :
 Machine Virtuelle, « Classe obligatoire », pas de Pointeurs,
bibliothèque sous forme de classes.
• C# : 2000 : MicroSoft
 Ressemble à Java, Pointeurs possible : « unsafe »
 Eléments de Qualité Logicielle
Critères de QUALITE d’un LOGICIEL :
• Exactitude :
 Résultats voulus, dans conditions normales d’utilisation,
• Robustesse :
 Aptitude à bien réagir, lorsque l’on s’écarte des conditions
normales d’utilisation,
• Extensibilité :
 Facilité d’Adaptation à l’évolution des Spécifications.
• Réutilisabilité :
 Possibilité d’utiliser certaines parties (modules) dans
d’autres applications,
• Portabilité :
 Utilisation d’un même logiciel dans différents
environnements
• Efficience :
 Temps d’Exécution, Taille Mémoire
 Programmation Structurée,
Programmation Orientée Objet
Et Qualité Logicielle
• Programmation Structurée :
 Wirth : Programme = Algorithmes + Structures de Données,
 Convient pour l’Exactitude et la Robustesse,
 Pas pour Extensibilité, Réutilisabilité car remise en cause des
données
• Programmation Orientée Objet :
 Objet = Données + Méthodes (fonctions à appliquer aux
données) ,
 Objet : Instance d’une Classe (Variable : instance d’un Type)
 Encapsulation : « Interfaces » : Méthodes pour Accéder aux
données
 Héritage : nouvelle classe à partir d’une ancienne : ajout de
nouvelles données et méthodes,
 Meilleures Extensibilité, Réutilisabilité, Maintenance d’un
Logiciel.
 Rappel de Langage C
• Instruction « Simple »:
 Se termine par « ; »,
• Bloc d’Instructions « Simples »:
 Plusieurs instructions simples successives entre { … }
 Vu comme une instruction simple, par une instruction de
structure,
• Instruction de Structures :
 Tests : if, else, Aiguillage : switch
 Boucles : do, while, for
 Pas de « ; » terminal, et agit sur une instruction simple.
• Types de Variables :
 De base : char, int, float,
 Qualificatifs : unsigned, short, long, double,
• Opérations :
 = (affectation), +, -, *, /, %, ++, -- (Pré et Post)
 Logique de Bits : &,|, <<, >>, ~, -
 Rappel de Langage C (fin)
• Fonctions :
 Approche « Fonctionnelle »,
 Passage de Paramètres : par Valeur, par Adresse,
• Les Pointeurs :
 Adresse de Variable, MAIS également de Fonction,
 Utilisation : Passage de Paramètres, Allocation Dynamique
de Mémoire, les Tableaux, Programmation Système,
• Entrées / Sorties :
 Standart : stdin, stdout, stderr,
 Fichiers : Lecture / Ecriture – Formatées et Binaires.
• Chaînes de Caractères :
 Terminaison par ‘\0’,
 Gestion par la bibliothèque « string »,
• Structures de Données :
 Accès aux champs par variable « . » ou par adresse « -> »
• Allocation Dynamique de Mémoire:
 Du C au C++

1. Mon Premier Programme:

2. Prototypes C++:
3. Entrées / Sorties Standard:
4. Allocation / Désallocation Mémoire:
5. Visibilité / Durée de Vie d’une Variable:
6. Passage de Paramètres : La Référence:
7. Arguments par Défaut:
8. Surcharge de Fonctions:
9. Fonctions « inline »:
[Link] Noms:
[Link] et Const:
Votre Premier Programme en C++

• Squelette : proche du C:
• Nouvelles Librairies :
• Nouvelles Fonctions
d’Entrées / sortie :
 cin, cout : + simples
• « Espaces Noms »
 Bibliothèques à portée
limitée
 Au lieu de sdt::cin
• Fonctions : idem C
 Prototype (si possible
dans un fichier « .h »)
 Appel,
 Définition
(PPremierProg)
Les Prototypes en C++
• Prototypes Complets :
 Nom des variables :
optionnel, non exploité
• Fonctions SANS Argument :
 Ne pas mettre « void »
• Programmation « Avancée »
 Dans un fichier « .h » avec
les structures de données
 Ne pas oublier : (idem C)
#ifndef _Def
#define _Def
Structures.h
#include "Structures.h"
#include "Structures.h"
#endif #include "Fonction1.h"
#include "Fonction2.h"
Fonction1.h

#include "Structures.h"

Principal.c
Fonction2.h
Les Prototypes, Appels,
Définitions
• A l’Appel : Mise en
Correspondance des
Arguments du Prototype et
de l’Appel :
 Correspondance Exacte,
 Non Dégradante : c-i, i-f,
f-d
 Dégradante : i-c, d-f, d-i,
f-i
• Si Prototypes et Définitions
dans un même fichier :
 Vérification Possible :
Correspondance des
types de paramètres doit
être exacte !
(PTestPrototypes)
Les Entrées / Sorties Standard

• Plus Simple et Intuitif:

 Pas à se soucier du type
de variable : %d, %f,
%lf, %s
 >> et << : sens de transit
de l’information, par
rapport à la variable
 cin >> Variable
 cout << Variable
• Plus Logique :
 Chaînes de caractères :
idem autres types de
base!
 cin et cout : opérateurs et
non fonctions …
(PTestEntreeSortie)
Pointeurs Génériques et
Allocation Mémoire
• Pointeur Générique :
void *:
 Allocation Dynamique
de Mémoire,
• En C++:
 Les pointeurs sont
typés,
 Cast Obligatoire,
• Nouveaux Opérateurs :
 new, delete
 Opérateurs ≠
fonctions : pas de
parenthèses !!
(PTestAllocMemoire)
 Les Variables

• Possibilité de déclarer une

varible « n’importe où » :
1  Globale (1), en dehors de
tout,
2  Locale : début de fonction
(2), de boucle (3), interne à
un bloc (4)
3 • Validité :
 (1) tout le fichier
4  (2) et (4) jusqu’à la fin du
bloc,
 (3) limité à la boucle
• Plusieurs variables peuvent
porter le même nom:
• Idée de B. Stroustrup:  Le compilateur doit pouvoir
 Déclarer une variable quand on en a faire la différence,
besoin  La variable la plus
• Qualité Logicielle : « interne » masque les
 En début de Fonction, avec un autres
commentaire sur l’utilisation (PTestVariables)
Le Passage de Paramètres :
Par Valeur
• Passage de Paramètres :
 La fonction appelée
reçoit une copie de la
variable, et non la
variable.
 Copie : dans la pile de
la fonction appelée
• Modifications :
 De la copie de la
variable
• Utilité :
 Passage de paramètres
à la fonction
(PTestPassageValeur)
Le Passage de Paramètres :
Par Adresse
• Passage de Paramètres :
 La fonction appelée reçoit
une copie de l’adresse de
variable,
 Copie : dans la pile de la
fonction appelée
• Modifications :
 De la variable, grâce à
son adresse
• Utilité :
 Passage de paramètres à
la fonction,
 Également en retour !!
• Difficulté (!?) :
 Variable et Pointeurs :
types différents
(PTestPassageAdresse)
Le Passage de Paramètres :
Par Référence
• La Référence : C++ :
 Nouveau type : ex : int &,
 Initialisation à la création,
par liaison à une variable.
 Pas de cht de liaison possible
• Utilité :
 Passage de Paramètres à une
fonction : Idem par Adresse !!
• Simplicité (!?) :
 Variable et Référence : types
« semblables », a priori plus
simple à programmer !
 Pas de conversion possible !
 Confusion possible !
 Existe en Java
(PTestPassageReference)
Les Arguments par Défaut

• Qu’est ce ?
 Arguments omis lors de la
transmission,
 Leur valeur est fixée par
défaut.
• Mise en Oeuvre :
 La valeur par défaut est fixée
dans le prototype,
 Donc par l’utilisateur et NON
le concepteur.
 Les arguments par défaut
sont les derniers !
 Les arguments non par défaut
sont obligatoires !
(PArgumentDefaut)
Surcharge d’une Fonction
(Overload)
• Qu’est ce ?
 Plusieurs fonctions peuvent
porter le même nom,
 Idem pour les opérateurs.
Existence implicite en C pour +,
-, / , *, etc …
 Le compilateur choisi la
fonction à mettre en oeuvre.
• Mise en Oeuvre :
 Grâce à la Signature de la
fonction, ie le type des variables,
 Recherche de correspondances
exactes, non dégradantes, puis
dégradantes !
 Erreur de compilation si
ambiguïté
(PTestSurcharge)
 Surcharge d’une Fonction
Ou Paramètres par Défaut ?

• Ne pas Utiliser de
Surcharge, lorsque l’on
peut utiliser les
paramètres par défaut :
 La même fonction
avec un nombre
variable de
paramètres,
 1 seule fonction à
écrire et compilée !
(PSurchargeouDefaut)
 La Spécification « inline »

• Fonction « inline »:
 Le Compilateur incorpore les
instructions en langage
machine de la fonction à
l’endroit de l’appel,
• Intérêts :
 Rapidité : pas d’appel réel de
fonction, ie de branchement
(CALL en assembleur),
 Vérification, comme pour une
fonction de la cohérence des
types (pas pour une macro
• Qualificatif « inline »: #define )
 Prototype, • Inconvénient :
 Définition.  Exécutable plus volumineux,
• « implicite »: si fonction appelée plusieurs
 Définition dans la classe. fois
(PTestFnctInline)
Les Espaces Nom

• Rappel :
 Utilisation pour la
bibliothèque standard : std
• Intérêts :
 Permet l’utilisation de
plusieurs bibliothèques
« incompatibles »,
 Permet de spécifier la fonction
de la bonne bibliothèque
 Utilisation : développements
« importants »
• Utilisation :
 Déclaration,
 Appel des fonctions,
 Implicite avec les classes
(PTestEspaceNom)
 Le type Bool
Le Qualificatif « const »
• Le type « bool » :
 true : true->1, ≠ 0 -> true,
 false : false  0
 Meilleure lisibilité du code
• Qualificatif « const » pour une variable globale :
 Portée limitée au fichier concerné,
 Est utilisée dans une expression constante : exemple la
définition d’un tableau
 Remplace par exemple : « #define NELT 10 »
 La Notion de CLASSE
1. Structure C++:
2. L’Encapsulation:
3. La CLASSE:
4. Constructeur / Destructeur:
5. Durée de Vie / Visibilité des Objets:
6. Construction / Destruction d’Objets Complexes:
7. Membre de Données Statique:
8. Fonctions Membres et C++:
9. Retour d’un Objet d’une Fonction Membre:
10. Constructeur de Recopie et Opérateur d’Affectation:
11. Objets Membres:
12. Fonctions et Méthodes Amies:
13. Sur-Définition des Opérateurs:
14. Casts et Affectations en C++:
15. Patrons de Fonctions:
16. Patrons de Classes:
Les Structures C++

• Structures = Regroupement :
 Données de type différent,
 Fonctions membres ou
Méthodes (nouveauté C++),
 Crée directement un nouveau
type de données, sans utiliser
« typedef ».
• Objet : Instance de la Structure :
 Type => Structure C =>
Structure C++,
 Variable => Variable
Structurée => Objet.
 Allocation Statique ou
Dynamique
• Données (idem C):
 Accès à partir d’une variable
structurée « . » ou d’un
pointeur « -> »
(PTestStructures)
Les Structures C++ (suite)

• Fonctions :
 Prototype : dans la structure,
 Définition : Utilisation de
l’Espace Nom, (MAIS ne pas
écrire « using namespace »)
 Appel : opérateurs « . » et
« -> », à partir d’un objet ou
de l’adresse d’un objet.
 Un objet « privilégié » : celui
qui appelle la fonction : pas en
paramètre.
• Recopie de Structures :
 Possible : b = a;
• Cohabitation Fonctions « C » et
Méthodes:
(PTestStructures)
 Les Structures C++ :
Code Complet (PTestStructure)
 L’ENCAPSULATION
• Interdire l’Accès Direct aux Données d’un Objet de
l’Extérieur de la « Classe » :
• La CLASSE :
 Extension de la Structure C++ permettant l’Encapsulation
• Accès aux Données :
 Seulement par des Fonctions Membre : « les Interfaces » ,
donc de l’Intérieur de la Classe,
• Les Interfaces :
 Fonctions membre permettant de lire / écrire les données
d’un objet,
 Accessibles de l’Extérieur de la Classe.
• Evolution, Maintenance d’un Logiciel :
 Classe (incluant Méthodes) : « bibliothèque logicielle »,
 Les interfaces restent inchangées : pas de modification du
code des programmes des « Utilisateurs »,
 Possibilité de modifier données et méthodes d’une classe
pour implanter des améliorations : nouvel algorithme plus
performant par ex …
 La « CLASSE »
• La CLASSE : Généralisation de la Structure C++ :
 Programmation Identique,
• Notion de « Statut »: « Gestion des Accès » :
 Des Champs (ie. Données) et des Méthodes,
 « individuel » pour chaque champ ou méthode
• 3 différents Statuts :
 Private : par défaut, accessible uniquement de l’intérieur
de la classe,
permet l’Encapsulation,
 Public : Accessible également par l’Extérieur de la Classe,
 Comme la structure C++,
 les interfaces doivent avoir ce statut.
 Protected : statut intermédiaire : pour l’Héritage !
 Private pour « l’Extérieur »,
 Public pour les Classes Dérivées.
Exemple de Programmation avec
la notion de « Classe »
• Choix des Statuts :
 Private,
 Public
• Encapsulation :
 Plus d’Accès aux Données
d’un Objet de l’Extérieur de
la Classe,
 Réalisation d’Interfaces.
 Validation des Statuts à la
Compilation :
Violation = Erreur de Compilation
 Ré-écriture de la fonction non
membre la classe, avec
interfaces (sauf « AMIE »).
• Même écriture des Méthodes
• Même utilisation des Méthodes
(PTestClasse)
 Les Classes:
Code Complet (PTestClasse)
 Les Classes:
Code Complet (PTestClasse)
 Constructeur et Destructeur
• Constructeur et Destructeur :
 Méthodes particulières, pour toute classe,
 Existence par défaut,
 Constructeur : Crée l’Objet / Destructeur : Détruit l’Objet
 Qualité Logicielle : « structure » la Création et la Libération
de la Mémoire
• Constructeur :
 A la Création Statique ou Dynamique (appelé par new) d’un
Objet,
 Utilité :
o Initialisation des champs de l’Objet,
o Objet « Complexe » (ie. Allocation dynamique en interne)
• Destructeur :
 Appel à la destruction de l’Objet :
o Dynamique (appelé par delete)
o Statique : objet local d’une fonction ou méthode, objet
local d’une boucle,
o Constat DevC++ : MAIS pas pour objet local du main()
Exemple de Programmation des
Constructeur et Destructeurs
• Syntaxe de Programmation:
 Constructeur :
o porte le nom de la classe,
o Peut avoir des paramètres,
 Destructeur :
o porte le nom de la classe,
précédé de « ~ »,
o Sans paramètre.
• Dès présence d’un constructeur ou
destructeur :
 Plus possibilité d’utiliser celui
par défaut, sans paramètre
pour le constructeur,
• Constructeur AVEC paramètres :
 Permets l’Initialisation des
Champs,
 Paramètres par défaut possible
(PTestConstructeurDestructeurSimple)
 Durée de Vie des Objets
Alloués Statiquement et Dynamiquement

• Validation « Constructeur et Destructeur » : (idem variables)

 Objets Alloués Dynamiquement : new … delete
 Objets Alloués Statiquement : création … fin du bloc … MAIS
 Observe t’on la Désallocation de l’objet local du main(), sans
l’appel explicite au destructeur ??
 Visibilité des Objets
Résultats d’Exécution

• Plusieurs objets peuvent porter le même nom : (idem variables)

 Mêmes règles que pour les variables : masquage !,
 L’appel au destructeur pour la variable local du main est
bien réalisé, MAIS ne la supprime pas !!!
(PTestVisibiliteObjet)
 Objets Complexe : Intérêt des
Constructeur / Destructeur
nlig • Objet « Complexe »:
 Comporte une Allocation Dynamique de Mémoire,
ncol  Construction : Allouer la Mémoire,
 Destruction : la Désallouer
prof
ptdata
• Pointeur d’ « Auto
Référence » : this :
 This pointe sur
l’objet appelant la
méthode,
 nlig = nlig :
impossible
 this->nlig : champ
nlig de l’objet,
 Meilleure lisibilité,
évite les erreurs !
(PTestObjetImage)
ObjetImage : Programmation

• Génie Logiciel:
 Code Propre : les
allocations et
désallocations de
mémoire sont
« implicites » : pas
d’oublie possible !
(PTestObjetImage)
 Membre de Données Statique

• Champ Commun à tous les Objets d’une Même Classe, en un

seul Exemplaire :
 Une seule Mémorisation, commune à tous les Objets,
 Initialisation : Variable Externe,
 Mise à Jour :
o Constructeur,
o Destructeur,
o Méthodes
(PTestMembreStatique)
 Membre de Donées Statique

• Utilisation:
 Comme un Membre
Ordinaire
(PTestMembreStatique)
 Fonction Membres et
Nouveautés du C++

• Toutes les Nouveautés du C++ relatives aux Fonctions sont

applicables aux Méthodes :
 Arguments par Défaut,
 Surcharge ou Surdéfinition,
 Fonctions « inline »
 Transmission d’Objets par Référence.
• Arguments par Défaut :
 Vus avec le Constructeur,
 Surcharge d’une Méthode

• Plusieurs Méthodes portent le

même nom :
 La Signature doit être
différente (type des arguments),
• Exemple de Surcharge de
Constructeur:
 Possibilité d’initialiser un
complexe en norme et
argument (en degré),
 Effectue des Calculs
(PTestSurchargeMethode)
Méthodes « inline »

• Même Principe que pour les

fonctions :
 Instructions incorporées à
l’endroit de l’appel.
• Deux mises en œuvre possibles :
 Définition à l’intérieur de la
classe : pas de qualificatif
« inline »,
 Méthode classique :
qualificatif « inline » pour :
o Le prototype,
o La définition
(PMethodesInline)
 Passage de Paramètres « Objet »
À une Fonction Membre

• Fonction Membre peut s’appliquer à au moins 2 objets :

 L’un d’eux est privilégié : celui qui appelle la méthode,
 Le second est passé en Paramètre
• 3 Possibilités :
 Par Valeur : n’assure pas le retour,
 Par Adresse : Programmation Pointeur,
 Par Référence : Ressemble à une Valeur.
• Appel et Passage des Objets :
 Appel : «a. » et «pa-> »
 Paramètres :
o Valeur : «b » et «*pb »
o Adresse : «&b » et «pb »
o Référence : «b » et «*pb »
(PTestPassageObjetParametre)
Passage de Paramètres « Objet »
À une Fonction Membre
 Retour d’un « Objet »
D’une Fonction Membre
• Retour Naturel :
 Par Valeur,
• Retour par Adresse ou par
Référence :
 Adresse ou Référence ≠
Objet : pas de
mémorisation,
 Allocation Dynamique
de l’Objet, dans la
Fonction.
• Retour de la Fonction :
 Code « d’Erreur »!
(PTestRetourObjetFonction)
 Retour d’un « Objet »
D’une Fonction Membre

• Allocation Dynamique de
l’Objet, dans la Fonction :
 Recopie des Objets :
Constructeur de Recopie
• La Recopie d’un Objet est effectuée lors :
 De la transmission d’un Objet en argument à une Fonction,
 Du Renvoi d’un Objet par Valeur comme résultat d’une
Fonction,
 De l’Initialisation, lors de sa création d’un objet avec un
autre objet de même type.
• Constructeur de Recopie par Défaut :
 Existe par défaut, comme le constructeur,
 Recopie Membre à Membre tous les champs de l’Objet,
 Effet « invisible »!
• Constructeur de Recopie :
 Méthode Particulière,
 Appelée par le Compilateur lors des Cas de Recopie,
 Syntaxe particulière :
o Nom : celui de la Classe,
o Paramètre : Référence d’Objet Constant de Même Type.
Constructeur de Recopie :
Exemple : Objet Simple

• Recopie
 Initialisation,
 Transmission
 Retour
(PTestConstructeurRecopie)
 Recopie d’un Objets Complexe :
Nécessité du Constructeur de Recopie
• Constructeur de Recopie par Défaut : Problème Identifié
 Recopie champ à champ l’objet,
 Pas d’Allocation de Mémoire, Pas de Recopie de la Mémoire
Allouée,
 Recopie uniquement de l’Adresse,
 Même problème en Langage C
 Recopie d’un Objets Complexe :
Nécessité du Constructeur de Recopie

• En C++ Constructeur de Recopie permet de résoudre ce

Problème :
 Résolution « impossible » en langage C,
 Dans le Constructeur :
o Allocation de la Mémoire,
o Recopie de la Mémoire allouée.
• Exemple de Visualisation du Problème :
 Allocation d’un 1er Objet,
 Recopie (classique) dans un Second,
 Destruction du 1er Objet, avec Destructeur Ad-Hoc,
=> Le second Objet n’a plus de Données !!!
 Exemple : Constructeur de
Recopie de l’Objet Image

• Constructeur de Recopie :
 Utilisation ou Non,
• Accès aux Pixels :
 getPixel : Lecture
 putPixel : Ecriture
(PTestRecopieObjetImage)
 Exemple :
Recopie de l’Objet Image

• Ne PLANTE pas SANS

Constructeur de Recopie !
 ? Hypothèse : Mauvaise
gestion de la mémoire par
Windows : ne vérifie pas les
accès !?
(Dépend de Windows)
• Ne PAS confondre avec
Affectation !
 Surcharge de l’opérateur =
 Affectation :
Sur Définition de l’Opérateur =
• Rappel : Création et Recopie d’un Objet est effectuée lors :
 De la transmission d’un Objet en argument à une Fonction,
 Du Renvoi d’un Objet par Valeur comme résultat d’une
Fonction,
 De l’Initialisation, lors de sa création d’un objet avec un
autre objet de même type.
=> Appel du Constructeur de Recopie
• ≠ Affectation :
 L’Objet est déjà Construit : PAS d’Appel à Constructeur,
 Existe également par Défaut, MAIS Même problème pour un
objet Complexe
 Recopie Membre à Membre tous les champs de l’Objet,
• SurDéfinition de l’Opérateur d’Affectation « = »:
 Recopie des Champs de Données, et Non d’Adresse,
 Recopie des Données autres,
 Paramètre : « Référence constante » .
 Sur Définition de l’Opérateur =
pour la Classe image
• Affectation:
 Pas d’Allocation
Mémoire,
 Recopie des Champs de
données, et des données
allouées « pointées ».
 Sur Définition de l’Opérateur ==
pour la Classe image
• Comparaison:
 Test des champs
statiques,
 Test des champs
dynamiques.
 Sur Définition de l’Opérateur +
pour la Classe image
• Surcharge Addition :
 Première Opérande :
Objet appelant ;
 Paramètre : Seconde
Opérande ;
Ecriture Dissymétrique.
 Objets Membres
• Objet Membre :
 Objet à l’Intérieur d’un autre
Objet,
 Objet Membre Transitoire
(par défaut)
• Implantation SANS Objet
Transitoire :
 Liaison des Constructeurs,
• Encapsulation: choix ≠ :
 Objet membre : public,
• Situation gérée plus Proprement
grâce à la Notion d’Héritage :
 Objet Membre : Solution C,
Non réellement C++ !
(PTestObjetMembre)
 Objets Membres : Code

• Notion « d’Héritage » :
 Implantation plus simple !
 Problème de l’Encapsulation

• L’ENCAPSULATION :
 Accès aux Données que par les Méthodes Membres de la
Classe,
 Impossibilité pour une Fonction indépendante ou une
Méthode d’une autre classe d’Accéder aux Données d’une
Classe Donnée.
• Problème : Pour un projet de plus grande ampleur :
 Plusieurs Classes Différentes en Considération,
 Nécessité de la Possibilité pour une fonction indépendante
ou une méthode d’accéder aux données d’un objet d’une
autre classe !!!
• Exemple : Géométrie Vectorielle (idem Affine) :
 Classes : Vecteur, Matrice,
 Produit :
o Matrice – Matrice => Matrice
o Matrice – Vecteur => Vecteur
 Fonctions et Méthodes Amies
• Notion : « d’Amitié » : Pour
Résoudre ce Problème
 Permet à une Fonction
indépendante ou une Méthode
d’une autre classe d’Accéder
aux Données d’une autre
Classe.
• 4 Possibilités: déclaration dans les
Prototypes de la classe amie
 Fonction Indépendante, Amie
d’une Classe,
 Fonction Membre d’une
Classe, Amie d’une autre
Classe,
 Fonction Amie de plusieurs
Classes,
 L’Ensemble des Méthodes
d’une Classe, Amies d’une
Autre Classe (PTestFonctionsAmies)
 Fonctions et Méthodes Amies

• Notion : « d’Amitié » :
 Permet l’Accès Direct au
champs pour une fonction
non méthode de la classe !
 Fonctions et Méthodes Amies
• Méthodes d’une Classe : Amies
d’une Autre Classe
 Variante de l’Implantation
précédente pour la méthode :
CompareNom :
o Déclaration de l’Amitié à
l’ensemble de la classe
 Sur Définition d’un Opérateur

• Sur Définition ou Sur Charge d’un Opérateur :

 Opérateur : +,-,*,/,&,|,% etc …
 Surcharge : Idem pour une Fonction !
• Existe « Implicitement » en Langage C :
 « + » addition d’entiers, de réels simples ou doubles,
 « * » multiplication ou contenu de l’adresse.
• En C++ : Extension possible sur les nouveaux types définis :
 Ex : Addition, Soustration, Multiplication … de nombres
complexes,
 Ecriture « naturelle » du code.
• Règles de Sur Définition d’un Opérateur:
 Se limite aux opérateurs existants sur les types de base,
 Conservation de la pluralité : unaire, binaire de l’opérateur,
 Interdit sur les types de base,
 Combinaison d’Opérateurs : « += » : réalisé avec les sur
définitions
 Sur Définition : Implantation

• Deux Possibilités :
 Fonction Membre :
dissymétrie des 2
opérandes,
 Fonction amie :
symétrie
• Syntaxe :
 Mot Clef :
« operator ».
• Ex d’Implantation:
 « + » : Méthode,
 « - » : Fonction
Amie.
• Utilisation :
 « Intuitive »
(PTestSurDefOperateurNC)
 Sur Définition : Implantation

• Retour sur le
Constructeur de
Recopie:
 Si défini : la
recopie doit être
faite !
• 2 Implantations ≠:
 Symétrique ou Non
 Opérateurs de Cast et
d’Affectation « = »en C++
• Positionnement du Problème :
 Cast : Changement de Type,
 Affectation : Recopie, si variables de même type, sinon « Cast
+ Recopie »,
 Implicite (ie. Caché) entre les types de Base.
• Exemples :
 char c, c1; int i, i1; float f, f1; double d, d1;
 c = c1; i = i1; f = f1; d = d1; // Affectations
 (int)c; (double)f; // Cast
 c = (char)i; d = f; i = d; // Cast puis affectation
• Avec de Nouveaux Types de Données : ex : Nombres Complexes
 Types non standards C++,
 A vous de définir les opérateurs de Cast et d’Affectation
• Possibilité:
 D’un Type de Base vers un Nouveau Type,
 D’un Nouveau Type vers un Type de Base,
 Entre Nouveaux Types.
 Opérateurs de Cast et
Opérateur d’Affectation = en C++
• Cast et Affectation:
 Cast : en un Type de Base,
 Affectation : en un Objet
• Nouvelle Syntaxe :
 N = int(x); // n = (int)x;
(PTestOperateurCastSimple)
 L’Ancienne C reste possible,
et même à utiliser si la
nouvelle est sur-définie !
• Nouvelles Possibilités :
 Cast avec les types de base,
 Cast entre nouveaux types,
 Affectations
• Opérateur de Cast :
 Méthode,
 Syntaxe : le type de la valeur
de retour n’est pas
mentionné
(PTestOperateurCast)
 Opérateurs de Cast et Opérateur
d’Affectation en C++

• Cast:
 Implicites lors de
l’Affectation;
• Affectations:

• Cast en type de base :

 Ancienne Syntaxe
Obligatoire;
Opérateurs de Cast et Opérateur
d’Affectation en C++

• Code de l’Affectation :
 Surcharge pour chaque
Type
 Les Patrons de Fonctions

• Patron de Fonctions = Modèle de Fonctions:

 Fonction Générique, avec différents Types de Données …
 « Remplace » les Macros en Langage C,
 Possibilité de plusieurs types ≠ de données ≠ !
• Plus Puissant qu’une Sur-Définition :
 1 seule écriture de la Fonction,
• Plus Restrictive qu’une Sur-Définition:
 1 seul Algorithme, pour toutes les Fonctions agissant sur des
données de type ≠ !
 Attention Correspondance Exacte au type de Données !
 Possibilité de Sur-Définition du Patron
o En général : nombre d’arguments ≠
• Le Type de Données peut être une classe:
 Sur-définition au préalable des opérateurs de la classe
(PTestPatronFonction et PTestPatronFonctionTD avec différents types)
 Les Patrons de Fonctions
Exemple :

• Syntaxe:
 template
 <class T>
 Prototype « classique » en T
• Sur-Définition:
• Correspondance Exacte :
 T est un type donné !
 Les Patrons de Fonctions
Exemple :

• Sur-Définition Opérateur <:

 Pour utiliser la Classe
NombreComplexe
• Avec Plusieurs Types de
Données ≠ :
 <classT, class U>,
 Possibilité : <T> = <U> !!!
 Les Patrons de Classes

• Patron de Classes = Modèle de Classes :

 Classe Générique, avec différents Types de Données …
 Ecriture en une seule fois de la Classe,
o Adaptation par le Compilateur aux différents types
• Fourniture de Code:
 Classe : définition + module objet pour les fonctions
membre,
 Patron de Classes : définition + Instruction des Fonctions
Membre
(PTestPatronClasse)
 Les Patrons de Classes :
Exemple de Code

• Syntaxe :
 Template <class T>,
 point <int> …
 Les Patrons de Classes :
Avec Spécification

• Spécification pour le type

« char » :
 Possible (?) pour une
méthode: pas sous
DevC++ ,
 Spécification pour
l’ensemble de la classe :
o Ré – écriture des
Méthodes
 Héritage et Polymorphisme

1. Héritage:
2. Construction / Destruction:
3. Encapsulation / Contrôle d’Accès:
4. Héritage et Patron de Classes:
5. La Classe Virtuelle:
6. Polymorphisme:
7. Ligatures Statiques / Dynamiques : Fonctions
Virtuelles:
8. Fonctions Virtuelles Pures et Classes Abstraites:
 L’HERITAGE

• Un des Concepts de la Progammation Orientée Objet POO :

• Réutilisabilité des Composants Logiciels :
 Classes : Définitions + Méthodes
• Par Héritage:
 La Classe Dérivée « héritera » des Potentialités de la Classe
de Base : Champs et Méthodes
 Ajout à la Classe Dérivée de Nouvelles Données et / ou
Fonctionnalités (Méthodes),
 Pas Besoin de recompiler la Classe de Base.
• Possibilité de SurDéfinition des Méthodes de la Classe de Base,
avec les Méthodes de la Classe Dérivée:
 Les Méthodes de la Classe Dérivée masquent celle de la
classe de base,
 Appel possible avec l’Espace Nom dans la classe dérivée,
 Pas de changement pour un Objet de la Classe de Base !
L’HERITAGE : par l’exemple

• Exemple:
 Classe de Base : point :
Coordonnée x, y
 Classe Dérivée : pixel =
point + intensité
• Syntaxe :
 « : public point »
• Sur Définition :
 Affiche()
 Utilisable avec les 2
classes
(PPointPixel)
 L’HERITAGE :
Construction et Destruction
• Construction:
 Appel Constructeur de la
Classe de Base, puis Dérivée
 Pris en charge par le C++
• Destruction:
 Ordre Inverse : Dérivée,
puis Base
• Initialisation dans la
Construction:
 Liaison des Constructeurs :
comme pour les Objets
Membres
 L’HERITAGE et l’Encapsulation:
Contrôle des Accès
• Contrôle des Accès à 2 niveaux:
 Conception de la Classe de Base,
 Conception de la Classe Dérivée
• Contrôle au Niveau de la Classe de Base :
 Statuts : Public et Privé, classe et utilisateurs,
 Nouveau Statut : Protégé « protected » : intermédiaire :
o Public vis-à-vis de la classe dérivée : possibilité d’accès
direct au champ,
o Privé vis-à-vis de l’utilisateur.
• Contrôle au Niveau de la Classe Dérivée:
 « class Derivee : public Base » : Ne modifie pas les droits de
la classe de Base
 « class Derivee : private Base » : Rend Privé pour les
utilisateurs la classe Dérivée : La classe Dérivée réalise
l’Encapsulation de la Classe de Base.
(PTestDroitAcces et PTestDroitAccesEncap)
 L’HERITAGE
et Statut « protected »
• Données et Méthodes de la
Classe de Base :
 Rappel : Appartiennent à
la Classe Dérivée,
 Accès Direct : Possible !
 Accès Direct : Impossible
avec private!
 Encapsulation de la Classe
de Base
• Encapsulation des Données
de la Classe de Base :
 Accès Direct : Impossible !
 Accès par LectureBase()!
 Héritage Réitéré
• Possibilité de Réitération de
l’Héritage :
 La Classe Dérivée devient
Classe de Base,
 Appel Constructeurs /
Destructeurs
(PTestHeritageReitere)
 Héritage et Patrons de Classes

• 3 Possibilités :
 Classe Ordinaire Dérivée d’une instance de Patron de
Classes,
 Patron de Classes, Dérivé d’une Classe Ordinaire,
 Patron de Classes, Dérivé d’un Patron de Classes, avec
« template commun » ou non.
• 3 Exemples :
 Classe pixelint, dérivée de l’instance <int> du patron de
classes pointP,
(PTestPatronHeritage)
 Patron de Classes pixelC, dérivée de la classe point,
(PTestPatronHeritage1)
 Patron de Classes pixelP, dérivée du Patron de classes pointP,
avec « template non commun ».
(PTestPatronHeritage2)
Classe Ordinaire Héritant d’une
instance de Patron de Classes
Patron de Classes Héritant
d’une Classe
Patron de Classes Héritant
d’unPatron de Classes
(Template non commun)
 Héritage Multiple

• Généralisation de l’Héritage
Simple:
 Une Classe Dérive d’au moins
deux Classes de Base,
• Syntaxe:
 Définition de la Classe,
 Constructeur
• Appel Constructeur :
 Base : dans l’ordre déclaré, puis
dérivée
• Appel Destructeur :
 Sens Inverse
• Possibilité d’avoir des champs de
même nom dans ldes classes
dérivées:
 Espaces noms
(PTestHeritageMultipleSimple)
Héritage Multiple
 Héritage et Mémorisations
Multiples

• Une Classe « Hérite » de plusieurs

fois la Même Classe :
 Combinaison Réitération et
Héritage Multiple,
• Effet :
 Multiple Mémorisation de la
Classe de Base
(PTestHeritageMultipleComplexe)
 Héritage et Mémorisations
Multiples

• Deux Appels au Constructeur de la

Classe de Base :
 Deux mémorisations
• Solution :
La Classe VIRTUELLE
 La Classe VIRTUELLE

• Permet d’éviter la double

Mémorisation:
 Indique que la classe ne sera
mémorisé qu’une fois dans les
descendants
• Qualificatif « virtual »:
 Syntaxe : dans l’Héritage
• Attention au Constructeur:
 Appelé AVANT les autres,
 La Classe Virtuelle doit
posséder un constructeur SANS
PARAMETRE!
 Héritage et POLYMORPHISME
• En POO : Un Objet de la Classe Dérivée peut remplacer un
Objet de la Classe de Base:
 En effet, toute la Classe de Base se retrouve dans la Classe
Dérivée
• Héritage et Objet:
 (1) Recopie possible d’un Objet de la Classe Dérivée, dans
un Objet de la Classe de Base, l’inverse est IMPOSSIBLE.
• Héritage et Fonction Membre :
 (2) Une Méthode de la Classe de Base peut être appelée par
un Objet de la Classe Dérivée,
 (3) Un Objet de la Classe Dérivée peut être passé en
Argument d’une Fonction ou Méthode à la place d’un Objet
de la Classe de Base
• Héritage et Pointeur ou Référence d’Objets :
 (4) La Conversion d’un Pointeur ou d’une Référence sur un
Objet de la Classe Dérivée en un Pointeur ou une Référence
sur un Objet de la Classe de Base est implicite.
En C++ un Pointeur sur un type d’Objet peut recevoir
l’adresse de n’importe quel type d’Objet Descendant
Héritage et POLYMORPHISME
Héritage et POLYMORPHISME

• Tests par l’Objet Dérivé:

 (1) Recopie dans Objet de
Base,
 (2) Appel Méthode Base,
 (3) Conversion en paramètre :
Valeur, Adresse, Référence et
(4) Appel !
 Héritage et POLYMORPHISME :
Typage ou Ligature
Statique ou Dynamique
• Typage ou Ligature:
 Choix de la Fonction à Appeler.

En C++, l’Appel d’une Méthode pour un Objet Pointé

conduit systématiquement à appeler la Méthode
correspondant au Type du Pointeur,
et non pas au Type effectif de l’Objet pointé

• Typage ou Ligature Statique :

 Choix effectué au moment de la Compilation.
• Problème:
 Un pointeur de type de la classe de Base peut pointer un
objet de la classe Dérivée,
 Appel de la Méthode de la classe de base, si surcharge !
 Héritage et POLYMORPHISME :
Typage ou Ligature
Statique ou Dynamique
• Typage ou Ligature Dynamique :
 Possible en C++,
 Au Moment de l’Exécution !
 Relie la méthode au type de l’Objet Pointé,
 Réalisé avec les Fonctions « Virtuelles »,
 Limitée aux classes dérivées,
 Toujours effectif en Java.
• Qualificatif « viryual »:
 Dans la définition de la Classe de Base.
• Fonctions Virtuelles:
 Une fonction déclarée virtuelle dans une classe, sera
soumise à la ligature dynamique dans la classe et ses
classes descendantes,
 Un constructeur ne peut pas être virtuel,
 La redéfinition d’une fonction virtuelle doit respecter le
type de retour.
 Héritage et POLYMORPHISME :
Typage ou Ligature
Statique ou Dynamique
• Tests:
 Conversion pointeurs
 Ligature Statique
 Ligature Dynamique
(PTestHeritagePolymorphisme)
 Fonction Virtuelles Pures
Et Classes Abstraites
• Intérêt : Architecture d’un Développement Informatique :
 Les Classes dérivées de la Classe Abstraite devront
obligatoirement comporter les méthodes de la classe
abstraite.
• Fonction Virtuelle « Pure » :
 Qualificatif « virtual »
 Définition nulle « = 0 »
• Classe Abstraite :
 Pas destinée à instancier des objets : pas de champ,
 Donne naissance à d’autres classes par héritage,
 Contient au minimum une fonction virtuelle pure.
• Exemple :
 ClasseAbstraite : contient la méthode Affichage(),
 Toute classe dérivée doit fournir cette méthode
 Fonction Virtuelles Pures
et Classes Abstraites
• Intérêt :
 Les Classes dérivées
contiennent les fonctions
virtuelles pures !
(PTestClasseAbstraite)
 Gestion des Exceptions

1. Exemple de Gestion d’Exceptions:

 Gestion des Exceptions
• Exception Logicielle :
 Anomalie dans l’Exécution d’un Programme, exemples:
donnée anormale, division par zéro etc …
• le C++ offre la possibilité de gérer les Anomalies.
• Mise en Oeuvre :
 Zone où l’on essaye le code, sachant qu’une exception
peut survenir : « try »
 Détection de l’Exception : Lancement d’un Objet
contenant des informations sur l’Anomalie « throw »
 Gestion de l’Anomalie : Lancement de la Routine
d’Exception « catch »
• Possibilité d’utiliser les facilités de la bibliothèque standard.
• Exemple :
 Entrée de valeur avec limite,
 Détection et gestion du débordement
(PGestionException)
 Gestion des Exceptions

• Mise en Oeuvre :
 Try
 Throw
 Catch
 En Résumé (1):
• La Classe:
 Regroupe données et méthodes,
 Permet l’encapsulation : protection des données, donc
création d’interface.
 Qualificatifs : private (par défaut), public (pour les
interfaces)
 Fonction Membres : utilisation de l’Espace Nom,
 Appel de Méthode : Objet privillégié.
• Notion d’Amitié:
 Pour assouplir l’encapsulation : accès aux données privées
d’une classe,
 Fonction indépendante, méthode d’une autre classe etc …
• Surcharge:
 Variables (dangereux)
 Fonctions indépendantes ou membres et Opérateurs :
signature : nombre et types de paramètres : Attention aux
paramètres par défaut, et à l’impossibilité de distinguer
variable de référence.
 En Résumé (2):
• Référence:
 Ressemble à une variable,
 Permet le retour d’un paramètre modifié.
• Paramètres par Défaut:
 Commence par les derniers,
 En priorité par rapport à la surcharge.
• Constructeur:
 Méthode particulière, appelée à la création de l’objet :
statique ou dynamique (new),
 Existe par défaut, SANS paramètre,
 Permet l’initialisation,
 L’écriture d’un constructeur annule l’utilisation du
constructeur par défaut, SANS paramètre,
 Permet la construction d’un objet complexe.
• Destructeur:
 Méthode particulière, appelée à la destruction de l’objet :
statique ou dynamique (delete), Existe par défaut
 Permet la destruction d’un objet complexe. (sinon visualise la
durée de vie)
 En Résumé (3):

• Pointeur d’Auto Référence : This:

 Signifie l’objet courant,
• Constructeur de Recopie:
 Méthode particulière, appelée lors de la transmission de
paramètre en argument par valeur, lors du retour par valeur,
et lors de la création et l’initialisation par un objet de même
type,
 Existe par défaut : effectue la recopie membre à membre :
erreur pour un objet complexe,
 Permet la recopie d’un objet complexe. L’objet doit être
recopié dans son intégralité.
• Affectation:
 Objet crée : pas de constructeur de recopie,
 Existe par défaut : recopie élément par élément : problème
pour un objet complexe.
 Sur définition de l’opérateur « = »
 En Résumé (4):

• Sur Définition des Opérateurs:

 Idem sur définition des fonctions,
 Permet d’étendre les opérations usuelles : par exemple
nombres complexes, vecteurs, matrices etc …
 Opérateurs portant sur deux objets : programmation
dissymétrique par fonction membre, ou symétrique par
fonction amie.