Cours Poo

Programmation Orientée Objet
(OOP)
Mise en œuvre C++
G. Cherradi 2020
https://www.researchgate.net/profile/Ghyzlane_Cherradi
OBJECTIFS GÉNÉRAUX
Ce cours donnera un aperçu des concepts et des paradigmes sous tendant les langages de
01 programmation;
Ce cours vise à donner à l’étudiant(e) une connaissance appliquée de la programmation et de la

02 philosophie orientée objet
Introduire/Maîtriser le langage C++ (syntaxe, encapsulation, héritage, polymorphisme, templates,

03 exceptions, etc.)
Programmation Orientée objet (POO)

2
G.CHERRADI
PROGRAMME
S1
→ Introduction (produit logiciel, programmation).
→ Paradigmes et langages de programmation
→ Type de donnée abstrait (ADT)
→ Notion d’objet
https://www.youracclaim.com/organizations/ibm/badges
→ Introduction à C++ ( objet, class, encapsulation, héritage, polymorphisme, interface, etc.)
Contrôle des connaissances (Quiz) + Badges

https://www.youracclaim.com/organizations/ibm/badges
G.CHERRADI Programmation Orientée objet (POO) 3

PRODUCTION LOGICIEL
Qu’est qu’un logiciel?
Application (store), SiteWeb, jeux, microcontrôleur,

etc.
Produire
Code source, exécutable. //www.ibm.com/skills/badges/
Mais avant le codage ???
4
QU’EST CE QUE LA PROGRAMMATION?
Définissons la «programmation» au sens large comme l'activité qui commence par une spécification
et conduit à sa solution sur un ordinateur.
Expressions Langage de Langage de Outil de traduction

des besoins modélisation programmation (ex: Compilateur Logiciel
(ex: Merise, UML) C,C++, java, python) /interpréteurs
Client
inscrivent leur réflexion dans des
modèles de pensée théoriques
appelés paradigmes.
inscrivent leur réflexion dans des
modèles de pensée théoriques
appelés paradigmes.
5
G.CHERRADI Programmation Orientée objets (POO)
CYCLES DE VIE
//www.ibm.com/skills/badges/
6
QU’EST CE QUE LA PROGRAMMATION?
Programmer, c'est donc :
Observer le réel en construire un modèle en choisissant une vision ou domaine d'interprétation

(application d'un paradigme).
Traduire ce modèle pour une machine via un langage dit «Langage de programmation».
7
LES PARADIGMES DE LA PROGRAMMATION
Paradigme Si le seul outil que vous avez
- Modèle théorique de pensée qui oriente la recherche et la réflexion est un marteau, vous verrez
scientifiques (Larousse). tout problème comme un clou.
[Abraham Marslow]
- Un outil de pensée, une manière de voire les choses (A. Comte-Sponville).
Paradigme de programmation
- Un outil de pensée qui oriente la façon d'analyser, de concevoir et de coder un programme

(G. Caplat).
- Un paradigme de programmation est une façon d'approcher la programmation informatique et de
traiter les solutions aux problèmes et leur formulation dans un langage de programmation approprié. Il
s'oppose à la méthodologie, qui est une manière d'organiser la solution des problèmes spécifiques du
génie logiciel.
Tout comme il existe plusieurs sciences, chacune proposant sa vision des choses, il existe plusieurs
paradigmes de programmation, chacun supportant une façon de décrire des comportements .
G.CHERRADI Programmation Orientée objets (POO) 8

LES PARADIGMES ET LANGAGES DE PROGRAMMATION
- Il y a beaucoup moins de paradigmes que de langages de

programmation, Langages
- Chaque “paradigme” permet la programmation facile d’un

certain niveau de interactivité;
- Chaque paradigme est défini par un ensemble de

concepts de programmation;
Paradigmes …
- Un paradigme = un ensemble de concepts;
Concepts …
9
LES LANGAGES DE PROGRAMMATION
1ère génération: langage machine, notation directement compréhensible par la machine.
2ème génération: langage d'assemblage, les instructions du processeur et les divers registres
disponibles sont représentés par des mots clés mnémotechniques (1950).
3ème génération : langages de haut niveau, langages procéduraux et structurés
- Besoins de gros programmes de calcul numérique ==> FORTRAN (1956)

- Besoin d'un langage permettant d'exprimer et de structurer aisément les constructions algorithmiques :
Algol 60, Algol 68, Pascal (1971), Modula-2 (1983), C (1972),
- Besoins de simulation du monde réel : Simula-67, Smalltalk (1972, 1980), Eiffel, C++ (1986), Java (2000)
4ème génération : langage de programmation permettant par exemple l'interrogation de base de données
avec une syntaxe proche du langage humain (SQL, Postscript, metafont).
5ème génération :des langages destinés à résoudre des problèmes à l'aide de contraintes, et non
d'algorithmes écrits. Ces langages reposent beaucoup sur la logique. Parmi les plus connus, on trouve
Prolog, OPS5 et Mercury.
LES LANGAGES DE PROGRAMMATION https://www.tiobe.com/tiobe-index/
TIOBE Index for September 2020. September Headline: Programming Language C++ is doing very well.

LES PARADIGMES DE PROGRAMMATION Procédurale
Modulaire
Programmation Problème de base
procédurale Abstraction
Programmation Instruction 1
structurée Instruction 2
…..
Instruction 20
Programmation Goto: instruction 2
impérative …..
Instruction 1000
l'algorithme s'exprime par des
ordres séquentiels d’exécution
des instructions
Résultat
Programmation Orientée objets (POO)

12
G.CHERRADI
LA PROGRAMMATION PROCÉDURALE (STRUCTURÉE)
Procédurale
- Basée sur des instructions/commandes: « fait quelque chose »
– Exemples: Fortran, COBOL, Pascal, C, etc...
Modulaire
- Basée sur le concept de procédure/fonction ou routine ou sous programme.
- Les sous-programmes utilisent des variables locales et agissent sur des Abstraction
arguments fournis explicitement en paramètre, par valeur ou par référence.
- Un sous programme peut être appelé à partir d’un autre sous-programme
procédure ou à partir de lui même (récursivité).
Structures de Données + Procédures = Programme
//Structure domino bool est_double (Domino*d){

Typedef struct { Return (d->M1==d->m2);
Int M1; // marque droite }
Int M2; // marque gauche
} domino; Int main (void ){
Domino*o;
Bool a =est_double(o);
}

13
G.CHERRADI
LA PROGRAMMATION PROCÉDURALE (STRUCTURÉE)
Procédurale
# include <iostream.h>
Données
const int taille_max=100; Modulaire
float vecteur [taille_max];
int top=0;
Abstraction
Fonctions
bool pile_vide() { return (top ==0); }
bool pile_pleine () { return (top==taille_max);
void initialiser_pile () { top =0;}
void inserer_pile (float valeur) { vecteur[top]=valeur; top+=1;}
float enlever_pile() {return vecteur[top]; top-=1;}
Utilisation
void main(){
initialiser_pile (); inserer_pile (5.2f); inserer_pile (3.2f);
while (!pile_vide()) { cout << enlever_pile() << endl; }
}

13
G.CHERRADI
DATA HIDING (PROGRAMMATION MODULAIRE)
Modula-2 Procédurale
Les applications informatiques devenant de plus en
plus complexes, il y a nécessité de : Modulaire
- travailler en équipe
- réutiliser des composants existants Abstraction
- faciliter la maintenance PASCAL
L’application est décomposée en Modules (packages, unités) indépendants.
Un module désigne généralement un ensemble de procédures et de

données qui y sont liées et qu'elles manipulent.
- Les modules communiquent entre eux par des appels de fonctions seulement et non en
partageant les données .
- Les données peuvent être échangées en passant par les paramètres des fonctions.

14
G.CHERRADI
DATA HIDING (PROGRAMMATION MODULAIRE)
Procédurale
Le module est essentiellement un ensemble de fichiers interdépendants qui
partagent leurs détails d'implémentation mais les cachent du monde extérieur. Modulaire
Data.h Code.Cpp
Abstraction
Struct S1 Fonction F1
1. Module
regroupant ce
Struct S2 Struct S3 Fonction F2
qui rapporte aux
dominos
Fonction F3
2. Module
regroupant ce
qui rapporte aux
joueurs
15
TYPE DE DONNÉE ABSTRAIT (ADT) Procédurale
Modulaire
Abstraction
Offering services without

highlighting internal
implementation.

17
G.CHERRADI
LES PARADIGMES DE PROGRAMMATION
Procédurale
(structurée)
Decide which procedures you want;

Use the best algorithms you can find;
Data Hiding
(Modulaire)
Modula-2 Decide which Modules you want;
Partition the program so that is hidden in modules;
The main avantage : Security (private)

Abstraction
Decide which types you want;

C# Provide a full set of operations for each type;
C++ The main avantage : Provide flexibility

18
G.CHERRADI
CRITIQUE PROCÉDURALE STRUCTURÉ
«Struct»
Phone
- color: char*; Les valeurs ne sont pas encapsulées,

- marque: char*; c'est-à-dire que l'on peut partout lire ou
- state: bool; modifier ces valeurs.
- password: char*;
«Operations»
Phone les traitements étant séparés, il est difficile de
+ call(phone*d): void; connaître exactement quelles sont toutes les
+ init(phone*,char*,bool): void opérations possibles sur ce type.
+ free(phone*,char*,bool):void
+ quit(phone*): bool

19
G.CHERRADI
CRITIQUE PROCÉDURALE STRUCTURÉ
les valeurs peuvent ne pas être correctement

Phone p initialisées. La variable risque d'avoir des valeurs
inconsistantes.
Call(0) Free(0) Init(0)
free(&p) free(&p) Il y a donc risque de ré-écriture de fonctions existantes ou de

définition de traitements qui ne correspondent pas à au champ
sémantique du type.
p.state=true

20
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Regroupement du code (opérations) et des données (variables) dans une
seule unité. La classe est un exemple d'encapsulation, car elle encapsule la
méthode et la propriété.

21
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Une classe est un type de données dont le rôle est de rassembler sous un même
nom à la fois données et traitements. (2) Classe et Objet
→ Les données attachées à une classe sont appelées attributs (ou données
membres). [characteristics]
→ Les traitements attachés à une classe sont appelés méthodes (ou fonctions
membres, opérations). [responsibilities, comportments].
→
Nom de la classe «Class»
Phone
- color: char*;
Champs, attributs - marque: char*; Type de l’attribut
Classe en UML
Données membres - state: bool;
- password: char*;
Visibilité
+ call(phone*d): void;
+ init(phone*,char*,bool): void Type de retour
Opérations, méthodes + free(phone*,char*,bool):void
fonctions membres - quit(phone*): bool
Paramétres 22
LE PARADIGME OBJET
Classes: Déclaration vs. définition (1) Encapsulation
(2) Classe et Obje
Déclaration (.h files)
- Liste des méthodes et attributs (fonctions & champs)

- c’est comme un « contrat »
Définition(.cpp files)
- implémentation des fonctions.

23
G.CHERRADI
LE PARADIGME OBJET
Définition de classe (1) Encapsulation
Avant de manipuler un objet, il faut définir la classe dont il provient, c’est-à-dire décrire
de quoi est composé la classe; méthodes et attributs. La définition d’une classe (2) Classe et Obje
effectue dans un fichier d’entête (header)(.h, .hpp). Le nom de ce fichier est souvent le
même que celui de la classe.
Visibilité
▪ ‘+’ correspond à public → aucune restriction. Il s’agit du plus bas niveau de restriction
d’accès, toutes les fonctions membres (de n’importe quelle classe) peuvent accéder aux
champs ou aux méthodes public .
▪ ‘-’ correspond à private→ Restriction d’accès le plus élevé. L’accès aux données et fonctions
membres est limité aux méthodes de la classe elle-même.
▪ ‘#’ correspond à protected →??

23
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
(2) Classe et Obje

24
G.CHERRADI
LE PARADIGME OBJET
Les données membres (attributs) permettent de conserver des informations relatives à la (1) Encapsulation
classe, tandis que les fonction membre (méthodes) représentent les traitement qu’il est
possible de réaliser avec les objets de la classe. Il existe deux façons de définir des fonctions (2) Classe et Obje
membres:
▪ En définissant la fonction (prototype et corps) à l’intérieur de la classe en une opération;
▪ En déclarant la fonction à l’intérieur de la classe et en définissant à l’extérieur (dans un autre fichier).

(meilleur lisibilité)( il est nécessaire de préciser à quelle classe cette dernière fait partie. On utilise
pour cela l’opérateur de résolution de portée noté ::).
// fichier Phone.h // fichier phone.cpp

// declaration des methodes à l’interieur de la classe // definition des methodes à l’exterieur de la classe
Class Phone #include "phone.h"
{ double Phone::call(Phone* ph){
Private :
int stockage; // traitements
bool state;
Public : return ph->state;
bool call(Phone* ph); }
};
25
G.CHERRADI
LE PARADIGME OBJET
Classes

25
G.CHERRADI
LE PARADIGME OBJET : CRÉATION D’OBJETS
L'instanciation est l'action d'instancier, de créer un objet à partir d'un modèle (classe). (1) Encapsulation
Elle est réalisée par la composition de deux opérations : l'allocation et l'initialisation.
(2) Classe et Obje
Un objet est une instance (une réalisation) d’une classe. Cela signifie qu'un objet est la
matérialisation concrète d'une classe. (3) Instanciation
Article
FC5348
FP1245 référence
Smart_Phone
Pantalon designation
5200
520 prixHT
10
50 quantité
prixTTC()
prixTransport()
Instance_de Retirer() Instance_de
Ajouter()
Instanciation de la classe Article

L'état d'un objet est la valeur de ses attributs. Deux objets de même type sont dans le même état
si leurs valeurs coïncident. Ces objets sont alors des clones

26
G.CHERRADI
LE PARADIGME OBJET : CRÉATION D’OBJETS
(1) Encapsulation
Un objet est une structure informatique regroupant :
– des variables, caractérisant l’état de l’objet, (2) Classe et Obje
– des fonctions, caractérisant le comportement de l’objet.
(3) Instanciation
En C++, il existe deux façons de créer des objets, c a d d’instancier une classe :
▪ Création statique
Créer un objet en lui affectant un nom, de la même façon qu’une variable:
NomClass NomObjet ();
Ainsi l’objet est accessible à partie de son nom. L’accès à partir d’un objet à un attribut ou une
méthode de la classe instanciée se fait grâce à l’opérateur . :

27
G.CHERRADI
LE PARADIGME OBJET
▪ Création dynamique (1) Encapsulation
La création d’objet dynamique se fait de la façon suivante:

(2) Classe et Obje
• Définition d’un pointeur du type de la classe à pointer;
• Création de l’objet dynamique grâce au mot clé new, renvoyant l’adresse de l’objet (3) Instanciation
nouvellement crée. (new : opérateur d’allocation mémoire).
• Affecter cette adresse au pointeur,
• Après utilisation: libération de l’espace mémoire réservé : delete
Syntaxe
Ou

28
G.CHERRADI
LE PARADIGME OBJET : MÉTHODES PARTICULIÈRES
La vie d'un objet se résume à trois épisodes fondamentaux : sa création, son (1) Encapsulation
utilisation puis sa destruction. La création et la destruction font appel à des méthodes
particulières : respectivement les constructeurs et le destructeur. (2) Classe et Objet
▪ Constructeur
(3) Instanciation
Un constructeur est une fonction membre qui sert à initialiser les données membres
Un constructeur possède les propriétés suivantes:
▪ Un constructeur porte le même nom que la classe dans laquelle il est défini;
▪ Un constructeur n’a pas de type de retour (même pas le void) :
▪ Un constructeur peut avoir des arguments.
▪ Sa définition n’est obligatoire que si elle est nécessaire au bon fonctionnement de la classe.
Si le développeur juge que la présence d’un constructeur n’est pas utile, un constructeur par défaut
est défini automatiquement par le compilateur si la classe n’en possède pas.

29
G.CHERRADI
▪ Constructeur de recopie (1) Encapsulation
Un constructeur de copie est une fonction membre qui initialise un objet à l'aide d'un autre
objet de la même classe. Un constructeur de copie a le prototype de fonction générale (2) Classe et Objet
suivant:
Syntaxe: NomClass(const NomClass & old_obj); (3) Instanciation
En C ++, un constructeur de copie peut être appelé dans les cas suivants:
▪ Lorsqu'un objet de la classe est renvoyé par valeur
▪ Lorsqu'un objet de la classe est passé (à une fonction) par valeur comme argument.
▪ Lorsqu'un objet est construit à partir d'un autre objet de la même classe.
▪ Lorsque le compilateur génère un objet temporaire.
Si nous ne définissons pas notre propre constructeur de copie, le compilateur C ++ crée un constructeur de
copie par défaut pour chaque classe qui effectue une copie par membre entre les objets. Le constructeur de
copie créé par le compilateur fonctionne bien en général. Nous devons définir notre propre constructeur de
copie uniquement si un objet a des pointeurs ou une allocation d'exécution de la ressource comme un handle
de fichier, une connexion réseau..etc.

30
G.CHERRADI
▪ Destructeur (1) Encapsulation
Un destructeur est une fonction membre qui détruit ou supprime un objet.
(2) Classe et Objet
Syntaxe: ~NomClass();
▪ Un destructeur est automatiquement appelé lorsque les objets sont détruits. (3) Instanciation
▪ Il ne peut pas être déclaré static ou const.
▪ Un destructeur n'a pas d'arguments.
▪ Un destructeur n’a pas de type de retour (même pas le void) :
▪ Un destructeur doit être déclaré dans la section publique de la classe.
Si nous n'écrivons pas notre propre destructeur en classe, le compilateur crée un destructeur par défaut
pour nous. Le destructeur par défaut fonctionne bien sauf si nous avons alloué dynamiquement de la
mémoire ou un pointeur dans la classe. Lorsqu'une classe contient un pointeur vers la mémoire allouée
dans la classe, nous devons écrire un destructeur pour libérer de la mémoire avant que l'instance de classe
ne soit détruite. Cela doit être fait pour éviter les fuites de mémoire.

31
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Namespace (2) Classe et Objet

Un espace de nom permet de regrouper plusieurs déclarations de variables, fonctions
et classes dans un groupe nommé.(ex: pratique) (3) Instanciation
Le pointeur this
Dans toutes les classes, on dispose d’un pointeur ayant pour nom this, qui pointe vers l’objet courant.
Point
this

32
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Transmission par référence (2) Classe et Objet
Pour modifier la valeur d’un paramètre réel dans une fonction, il faut passer ce
(3) Instanciation
paramètre par référence
Une référence sur une variable est un synonyme de cette variable, c’est-à-dire une
autre manière de désigner le même emplacement mémoire.
On utilise le symbole & pour la déclaration d’une référence:
<type> &<nom> = <nom var>;

Par exemple :
int v = 5;
int &r = v; // r est une référence sur v

33
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Mot clé const
(2) Classe et Objet
Les méthodes constantes sont des méthodes de « lecture seule ».
Elles possèdent le mot-clé const à la fin de leur prototype. Des méthodes qui ne doivent (3) Instanciation
pas modifier les valeurs des données membres de la classe, ni retourner une référence
non constante ou un pointeur non constant d’une donnée membres.
- Lorsqu'une fonction est déclarée comme const, elle peut être appelée sur n'importe
quel type d'objet, objet const ainsi que sur des objets non const.
- Chaque fois qu'un objet est déclaré comme const, il doit être initialisé au moment de
la déclaration. cependant, l'initialisation de l'objet lors de la déclaration n'est possible
qu'avec l'aide de constructeurs.

34
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Mot clé static (2) Classe et Objet
Le mot-clé static a différentes significations lorsqu'il est utilisé avec différents types. Nous (3) Instanciation
pouvons utiliser un mot-clé statique avec:
- Variables statiques: variables dans une classe.
- Membres statiques de classe: objets de classe et fonctions dans une classe.
Variables statiques dans une classe: les variables déclarées comme statiques ne sont initialisées qu'une seule
fois, car elles disposent d'un espace alloué dans un stockage statique séparé, les variables statiques d'une classe
sont partagées par les objets. Il ne peut pas y avoir plusieurs copies des mêmes variables statiques pour différents
objets. Aussi pour cette raison, les variables statiques ne peuvent pas être initialisées à l'aide de constructeurs.
Fonctions statiques dans une classe: tout comme les variables statiques à l'intérieur de la classe, les fonctions
membres statiques ne dépendent pas non plus de l'objet de la classe. Nous sommes autorisés à invoquer une
fonction membre statique à l’aide de l’objet et de l’opérateur «.», Mais il est recommandé d’appeler les membres
statiques à l’aide du nom de classe et de l’opérateur de résolution de portée(::) .
Les fonctions membres statiques sont autorisées à accéder uniquement aux membres de données statiques ou à
d'autres fonctions membres statiques, elles ne peuvent pas accéder aux membres de données non statiques ou
aux fonctions membres de la classe.

35
G.CHERRADI
LE PARADIGME OBJET
Surcharge de Fonctions (overload)
La surcharge de fonctions est une fonctionnalité en C ++ où deux ou plusieurs fonctions peuvent avoir le
même nom mais des paramètres différents.
Le compilateur sélectionnera la fonction à appeler en fonction du type et du nombre des arguments qui
figurent dans l’appel de la fonction.
En C ++, les déclarations de fonction suivantes ne peuvent pas être surchargées.

- Déclarations de fonction qui diffèrent uniquement par le type de retour.
int Fun() ;
void Fun();
- Les déclarations de fonction membre portant le même nom et le nom parameter-type-list ne peuvent
pas être surchargées si l'une d'entre elles est une déclaration de fonction membre statique.
static int Fun(string s) ;
int Fun(string s);

36
G.CHERRADI
LE PARADIGME OBJET
Surcharge de Fonctions (overload)
En C ++, les déclarations de fonction suivantes ne peuvent pas être surchargées.

- Les déclarations de paramètres qui ne diffèrent que par un pointeur * par rapport à un tableau [] sont
équivalentes. Autrement dit, la déclaration de tableau est ajustée pour devenir une déclaration de
pointeur. Seules les dimensions du deuxième tableau et les suivantes sont significatives dans les
types de paramètres.
int Fun(int tab[]) ;
void Fun(int *tab);
- Les déclarations de paramètres qui ne diffèrent que par la présence ou l'absence de const sont
équivalentes. Autrement dit, les spécificateurs de type const pour chaque type de paramètre sont
ignorés lors de la détermination de la fonction déclarée, définie ou appelée.
int Fun(const int x) ;

int Fun(int x);

37
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Surcharge d'opérateurs
(2) Classe et Objet
Un operateur peut être définit comme une fonction membre;
(Ex : + s’appelle en réalité operator+(). ) (3) Instanciation
En C ++, nous pouvons faire fonctionner les opérateurs pour les classes définies par l'utilisateur.
Cela signifie que C ++ a la capacité de fournir aux opérateurs une signification spéciale pour un
type de données, cette capacité est connue sous le nom de surcharge d'opérateurs.
Par exemple, nous pouvons surcharger un opérateur «+» dans une classe comme String
afin de pouvoir concaténer deux chaînes en utilisant simplement +.
▪ NomClass operator+(NomClass const& a, NomClass const& b);
Presque tous les opérateurs peuvent être surchargés sauf quelques-uns. Voici la liste des opérateurs qui ne
peuvent pas être surchargés.
.(dot)
::
?:
sizeof

38
G.CHERRADI
LE PARADIGME OBJET
Les fonctions amies
En principe, l’encapsulation interdit à une fonction membre d’une classe ou toute fonction d’accéder à des
données privées d’une autre classe. Mais grâce à la notion d’amitié entre fonction et classe, il est possible,
lors de la définition de cette classe d’y déclarer une ou plusieurs fonctions (extérieurs de la classe) amies
de cette classe.
Il existe plusieurs situations d’amitiés :
1. Fonction indépendante, amie d’une classe.
2. Fonction membre d’une classe, amie d’une autre classe.
3. Fonction amie de plusieurs classes.
4. Toutes les fonctions membres d’une classe, amies d’une autre classe.
Pour déclarer une fonction amie d’une classe, il suffit de la déclarer dans cette classe en la précédent par le
mot clé ‘friend’.

39
G.CHERRADI
LA CLASSE STRING
Présentation de la classe string
- Il s'agit d'une classe standard qui permet de représenter une chaîne de caractères.
- Pour l'utiliser, il faut rajouter #include <string>.
- Cette classe encapsule des données pour pouvoir effectuer toutes les opérations de base sur les
chaînes.
Comment utiliser les string ?
- Déclaration et initialisation : string s1,s2= " hello";
- Affichage et saisie : cout<<s1; cin >> s1;
- Concaténation : string s3=s2+s1;
Séparateurs
• Par défaut, lorsqu'on saisit une chaîne de caractères en utilisant cin, le séparateur est l'espace : cela
empêche de saisir une chaîne de caractères comportant une espace.
• La fonction getline(iostream &,string) permet de saisir une chaîne de caractères en utilisant le passage à
la ligne comme séparateur : notre chaîne de caractères peut alors comporter des espaces.

40
G.CHERRADI
LE PARADIGME OBJET
- Macro assert
void assert( int condition );
Une assertion est utilisée pour tester l'état d'une variable ou d'une zone de mémoire : si la valeur qui y est stockée est
incohérente par rapport à ce que vous attendez, votre programme sera alors interrompu et un message d'erreur sera alors
affiché sur la console.
condition : condition à évaluer pour déclencher ou non l'assertion. Si la valeur est vrai (n'importe quelle valeur entière non
nulle), l'assertion ne sera pas déclenchée. Si la valeur est fausse (égale à 0), l'assertion sera déclenchée et le programme
s'arrêtera en affichant un message d'erreur relatif à l'assertion.
Aucune valeur de retour n'est produite par cette fonction.

41
G.CHERRADI
LE PARADIGME OBJET https://docs.microsoft.com/en-us/cpp/build/walkthrough-
creating-and-using-a-static-library-cpp?view=msvc-160
- Create and use a Static Library (MSDN)

PCH : les inclusions qui reviennent un peu souvent

42
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
Pourquoi et quand utiliser l'héritage?

(2) Classe et Objet
Voiture Bus Truck (3) Instanciation

-id: int -id: int
--id: int
-marque: string -marque: string
-marque: string
-vitesse: int
-vitesse: int
-vitesse:int (4) Héritage simple
+ afficher(): void + afficher(): void
+ afficher(): void +freiner (): int
+freiner (): int
+freiner (): int
+fuelQte():intduplication du même codeint3 fois
+fuelQte(): int +fuelQte():
Sans l’héritage
- Duplication du même code 3 fois.
- Cela augmente les risques d'erreur et de redondance des données.
LE PARADIGME OBJET Classe mere
Classe de base (1) Encapsulation
Pourquoi et quand utiliser l'héritage? superClasse
(2) Classe et Objet
Vehicule
En utilisant l'héritage, nous devons écrire les -id: int
(3) Instanciation
#marque: string
fonctions une seule fois au lieu de trois fois -vitesse: int
car nous avons hérité du reste des trois
classes de la classe de base (Vehicule). + afficher(): void (4) Héritage simple
+freiner (): int
+fuelQte(): int
Voiture Bus
Truck
Avec l’héritage Hybrid
- éviter la duplication des données Classe filles
- augmenter la réutilisabilité Sous-classes
Classe derivés
LE PARADIGME OBJET
(1) Encapsulation
Spécialiser et factoriser : important pour la réutilisabilité
(2) Classe et Objet
- Les connaissance les plus générales sont mises en commun dans des classes qui sont ensuite
spécialisées par définitions de sous-classes (connaissances spécifique). (3) Instanciation
- Une sous-classe est donc la spécialisation de la description d’une classe

appelée sa superclasse. (4) Héritage simple
- Une sous-classe hérite de sa superclasse.
- Conceptuellement tout se passe comme si les informations de la superclasse

étaient recopiées dans la sous-classe.
- La spécialisation d’une classe peut être réalisée selon deux techniques:
-- l’enrichissement : la sous-classe est dotée de nouvelles variables d’instances et/ou méthodes.
-- substitution : donner une nouvelle définition à une méthode hérité, lorsque celle-ci se révèle
inadéquate pour l’ensemble des objets de la sous-classe (masquage). Pour masquer une fonction, il
suffit qu'elle ait le même nom qu'une autre fonction héritée. Le nombre et le type des arguments ne
joue aucun rôle.
LE PARADIGME OBJET
(1) Encapsulation
L’héritage permet d’ajouter des propriétés à une classe existante pour en obtenir une
nouvelle plus précise. Il permet donc la spécialisation ou la dérivation de types (2) Classe et Objet
Propriétés de l’héritage (3) Instanciation
L’héritage est une relation entre classes qui a les propriétés

suivantes : (4) Héritage simple
– si B hérite de A et si C hérite de B alors C hérite de A A
– une classe ne peut hériter d’elle-même
– si B hérite de A, A n’hérite pas de B
– il n’est pas possible que B hérite de A, C hérite de B et que A
D
hérite de C
– le C++ permet à une classe C d’hériter des propriétés des
classes A et B (héritage multiple) B
La classe fille n’a pas accès aux données (privées)

de la classe mère. C

LE PARADIGME OBJET
(1) Encapsulation
Mode public: si nous dérivons une sous-classe d'une classe de base publique. (2) Classe et Objet
Ensuite, le membre public de la classe de base deviendra public dans la classe
dérivée et les membres protégés de la classe de base deviendront protégés dans
la classe dérivée. (3) Instanciation
Mode protégé: si nous dérivons une sous-classe d'une classe de base protégée. (4) Héritage simple
Ensuite, les membres publics et protégés de la classe de base deviendront
protégés dans la classe dérivée.
duplication du même code 3 fois
Mode privé: si nous dérivons une sous-classe d'une classe de base privée.
Ensuite, le membre public et les membres protégés de la classe de base
deviendront Private dans la classe dérivée.
class A
{
public:
int x;
protected:
int y;
private:
int z;
};
class B : public A
{
// x is public
// y is protected
// z is not accessible from B
};
class C : protected A
{
// x is protected
// y is protected
// z is not accessible from C
};
class D : private A // 'private' is default for

classes
{ Ne pas confondre le mode de dérivation
// x is private
// y is private
et le statut des membres d’une classe.
// z is not accessible from D
};
LE PARADIGME OBJET
(1) Encapsulation
(2) Classe et Objet
(3) Instanciation
(4) Héritage simple
Un graphe d'héritage simple

45
G.CHERRADI
LE PARADIGME OBJET
(1) Encapsulation
constructeurs/destructeurs/constructeurs par copie
(2) Classe et Objet
• Pas d’héritage des constructeurs et destructeurs➔ il faut les
(3) Instanciation
redéfinir.
• Appel implicite des constructeurs par défaut des classes de base
(super-classe) avant le constructeur de la classe dérivée (sous-
classe)
• Possibilité de passage de paramètres aux constructeurs de la
classe de base dans le constructeur de la classe dérivée par
appel explicite.
• Appel automatique des destructeurs dans l'ordre inverse des
constructeurs.
• Pas d’héritage des constructeurs de copie et des opérateurs
d'affectation.
Fonction virtuelle (1) Encapsulation
Une fonction virtuelle est une fonction membre qui est déclarée dans une classe de (2) Classe et Objet
base et redéfinie (Overriden) par une classe dérivée. Lorsque vous faites référence à
un objet de classe dérivée à l’aide d’un pointeur ou d’une référence à la classe de
(3) Instanciation
base, vous pouvez appeler une fonction virtuelle pour cet objet et exécuter la version
de la classe dérivée de la fonction.
- Les
Une fonctions
fonction virtuelles
virtuelle est unegarantissent que laqui
fonction membre fonction correcte
est déclarée dansestune
appelée
classepour un et redéfinie () par une
de base
classe
objet, dérivée.
quel queLorsque
soit levous
typefaites
de référence à(ouun objet de classe
pointeur) utilisédérivée à l’aidede
pour l'appel d’un pointeur ou d’une
fonction.
référence à la classe de base, vous pouvez appeler une fonction virtuelle pour cet objet et exécuter la version de
- Ils sont principalement utilisés pour la réaliser
classeledérivée
Runtime polymorphisme.
de la fonction.
- Les fonctions sont déclarées avec un mot clé virtuel dans la classe de base.
- La résolution de l'appel de fonction est effectuée au moment de l'exécution.
Le polymorphisme au moment de l’execution est obtenu uniquement via un pointeur

(ou une référence) de type classe de base. En outre, un pointeur de classe de base
peut pointer vers les objets de la classe de base ainsi que vers les objets de la classe
dérivée.
Règles pour les fonctions virtuelles (1) Encapsulation
- Les fonctions virtuelles ne peuvent pas être statiques et ne peuvent pas non plus (2) Classe et Objet
être une fonction amie d'une autre classe.
- Les fonctions virtuelles doivent être accessibles à l'aide d'un pointeur ou d'une
référence de type de classe de base pour obtenir un polymorphisme d'exécution. (3) Instanciation
- Le prototype des fonctions virtuelles doit être le même en base et en classe
dérivée. (4) Héritage simple
- fonction
Une Ils sont virtuelle
toujoursest définis dans lamembre
une fonction classe quide est
base et remplacés
déclarée dans unedans
classelade
classe
base et redéfinie (Overriden)
dérivée. Il n'est pas obligatoire pour la classe dérivée de remplacer (ou redéfinir
par une classe dérivée. Lorsque vous faites référence à un objet de classe dérivée à l’aide la d’un pointeur ou d’une
fonction
référence à lavirtuelle),
classe dedans
base,ce caspouvez
vous la version de une
appeler classe de base
fonction de la
virtuelle fonction
pour estet exécuter la version de
cet objet
utilisée. la classe dérivée de la fonction.
- Une classe peut avoir un destructeur virtuel, mais elle ne peut pas avoir de
constructeur virtuel.
Redéfinition/Sur-définition (surcharge)
(1) Encapsulation
Surcharge (Sur-définition) de fonction (au moment de la compilation)
(2) Classe et Objet
Il fournit plusieurs définitions de la fonction en modifiant la signature, c'est-à-dire en modifiant le
nombre de paramètres, en modifiant le type de données des paramètres, le type de retour ne joue
aucun rôle. (3) Instanciation
- Cela peut être fait aussi bien en classe de base qu'en classe dérivée.
Exemple:
void Fun(int* a); (4) Héritage simple
void Fun (int a[], char b);
Redéfinition de fonction (au moment de l'exécution)
C'est la redéfinition de la fonction de classe de base dans sa classe dérivée avec la même signature,
c'est-à-dire le type de retour et les paramètres.
- Cela ne peut être fait qu'en classe dérivée.
Class a Class b:public a
{ {
public: virtual void display() public: void display()
{ {
cout << "hello"; cout << "bye";
} };
} ; }
(1) Encapsulation
Surcharge de fonction VS Redéfinition de fonction
(2) Classe et Objet
• Héritage: la redéfinition des fonctions se produit lorsqu'une classe est
héritée d'une autre classe. Une surcharge peut se produire sans héritage. (3) Instanciation
• Signature de fonction: les fonctions surchargées doivent différer dans la
signature de la fonction, c'est-à-dire que le nombre de paramètres ou le
type de paramètres doivent différer. En cas de redéfinition, les signatures
de fonction doivent être identiques.
• Portée des fonctions: les fonctions Overridden sont dans des portées
différentes; alors que les fonctions surchargées sont dans la même
portée.
• Comportement des fonctions: la redéfinition est nécessaire lorsque la
fonction de classe dérivée doit effectuer un travail ajouté ou différent de la
fonction de classe de base. La surcharge est utilisée pour avoir des
fonctions de même nom qui se comportent différemment selon les
paramètres qui leur sont passés.

41
G.CHERRADI
Compatibilité entre classe de base et classe dérivée (1) Encapsulation
(2) Classe et Objet

- Possibilité de convertir implicitement une instance d’une classe
(3) Instanciation
dérivée en une instance de la classe de base, si l’héritage est
public. (4) Héritage simple
- L’inverse n’est pas possible : impossibilité de convertir une
instance de la classe de base en instance de la classe dérivée.
ClasseMere A;
ClasseDérivée B;
A=B; // Valide, appel de l’opérateur = de la classe de Base
// s’il a été redéfini ou de l’opérateur par défaut sinon
B=A; // invalide// error: no match for 'operator=' in ‘B = A'

41
G.CHERRADI
(2) Classe et Objet

- Possibilité de convertir un pointeur sur une instance de la
classe dérivée en un pointeur sur une instance de la classe de (3) Instanciation
base, si l’héritage est public
ClasseMere a, * p1=NULL;
ClasseDérivée b, * p2=NULL;
p1=&a; p2=&b;
p1->affiche() ; // Appel de ClasseMere::affiche();
p2->affiche() ; // Appel de ClasseDérivée::affiche();
p1=p2; // valide: ClasseDérivée* vers ClasseMEre*
p1->affiche(); // Appel de ClasseMere::affiche(); // et non de ClasseDérivée::affiche();
p2=p1; // erreur sauf si on fait un cast explicite // error: invalid conversion from
`ClasseMere*' to `ClasseDérivéé*’
p2= (ClasseDérivée*) p1; // Possible mais Attention les attributs membres // de la classe
dérivée n’auront pas de valeur
41
G.CHERRADI
Le polymorphisme (1) Encapsulation
Le mot polymorphisme signifie avoir de nombreuses formes. En termes simples,

(2) Classe et Objet
nous pouvons définir le polymorphisme comme la capacité d'un message à être
affiché sous plus d'une forme. Un exemple réel de polymorphisme, une personne en
même temps peut avoir des caractéristiques différentes. Comme un homme en (3) Instanciation
même temps est un père, un employé. Ainsi, la même personne a un comportement
différent dans différentes situations. C'est ce qu'on appelle le polymorphisme. Le (4) Héritage simple
polymorphisme est considéré comme l'une des caractéristiques importantes de la
programmation orientée objet.
(5) Polymorphisme
En C ++, le polymorphisme est principalement divisé en deux types:
- Compile time Polymorphism Polymorphism

- Runtime Polymorphism
Compile time Run time
Function Operator Virtual

Overloading Overloading Functions
41
G.CHERRADI
(2) Classe et Objet

- Possibilité de convertir un pointeur sur une instance de la
classe dérivée en un pointeur sur une instance de la classe de (3) Instanciation
base, si l’héritage est public
ClasseMere a, * p1=NULL;
ClasseDérivée b, * p2=NULL;
p1=&a; p2=&b;
p1->affiche() ; // Appel de ClasseMere::affiche();
p2->affiche() ; // Appel de ClasseDérivée::affiche();
p1=p2; // valide: ClasseDérivée* vers ClasseMEre*
p1->affiche(); // Appel de ClasseMere::affiche(); // et non de ClasseDérivée::affiche();
p2=p1; // erreur sauf si on fait un cast explicite // error: invalid conversion from
`ClasseMere*' to `ClasseDérivéé*’
p2= (ClasseDérivée*) p1; // Possible mais Attention les attributs membres // de la classe
dérivée n’auront pas de valeur
41
G.CHERRADI

Cours Poo

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Poo

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée Objet

Ce cours vise à donner à l’étudiant(e) une connaissance appliquée de la programmation et de la

Introduire/Maîtriser le langage C++ (syntaxe, encapsulation, héritage, polymorphisme, templates,

Programmation Orientée objet (POO)

→ Introduction (produit logiciel, programmation).

→ Paradigmes et langages de programmation

→ Type de donnée abstrait (ADT)

Contrôle des connaissances (Quiz) + Badges

G.CHERRADI Programmation Orientée objet (POO) 3

Application (store), SiteWeb, jeux, microcontrôleur,

Code source, exécutable. //www.ibm.com/skills/badges/

Mais avant le codage ???

Expressions Langage de Langage de Outil de traduction

Programmer, c'est donc :

Observer le réel en construire un modèle en choisissant une vision ou domaine d'interprétation

- Un outil de pensée qui oriente la façon d'analyser, de concevoir et de coder un programme

G.CHERRADI Programmation Orientée objets (POO) 8

- Il y a beaucoup moins de paradigmes que de langages de

- Chaque “paradigme” permet la programmation facile d’un

- Chaque paradigme est défini par un ensemble de

1ère génération: langage machine, notation directement compréhensible par la machine.

3ème génération : langages de haut niveau, langages procéduraux et structurés

- Besoins de gros programmes de calcul numérique ==> FORTRAN (1956)

G.CHERRADI Programmation Orientée objets (POO) 11

Programmation Orientée objets (POO)

Structures de Données + Procédures = Programme

//Structure domino bool est_double (Domino*d){

Programmation Orientée objets (POO)

Programmation Orientée objets (POO)

Un module désigne généralement un ensemble de procédures et de

Programmation Orientée objets (POO)

Offering services without

Programmation Orientée objets (POO)

Decide which procedures you want;

The main avantage : Security (private)

Decide which types you want;

Programmation Orientée objets (POO)

- color: char*; Les valeurs ne sont pas encapsulées,

Programmation Orientée objets (POO)

les valeurs peuvent ne pas être correctement

Call(0) Free(0) Init(0)

free(&p) free(&p) Il y a donc risque de ré-écriture de fonctions existantes ou de

Programmation Orientée objets (POO)

Programmation Orientée objets (POO)

(2) Classe et Obje

Déclaration (.h files)

- Liste des méthodes et attributs (fonctions & champs)

- implémentation des fonctions.

Programmation Orientée objets (POO)

▪ ‘#’ correspond à protected →??

Programmation Orientée objets (POO)

(2) Classe et Obje

Programmation Orientée objets (POO)

▪ En déclarant la fonction à l’intérieur de la classe et en définissant à l’extérieur (dans un autre fichier).

// fichier Phone.h // fichier phone.cpp

Programmation Orientée objets (POO)

Instanciation de la classe Article

Programmation Orientée objets (POO)

Créer un objet en lui affectant un nom, de la même façon qu’une variable:

NomClass NomObjet ();

Programmation Orientée objets (POO)

La création d’objet dynamique se fait de la façon suivante:

Programmation Orientée objets (POO)