Cours POO C++ Partie I

Université Sidi Mohamed Ben Abdallah
Ecole Nationale des Sciences Appliquées

Fès
PROGRAMMATION AVANCÉE
CONCEPTION ORIENTÉE OBJET (C++)
S. EL GAROUANI
S. EL GAROUANI ENSA Fès 2017-2018
Objectifs
• Maîtriser les bases du langage C++
• Comprendre les concepts de la programmation Objet en C++ et

définir les avantages de la POO par rapport à la programmation
procédurale
• Encapsulation, Composition, Héritage, polymorphisme
• Mettre en pratique la gestion des exceptions
S. EL GAROUANI ENSA Fès 2017-2018 2
1
Sommaire
I. Présentation des apports de C++

II. Concepts de l’approche orientée objet
III. POO : classes et objets
IV. POO : dérivation, héritage
V. Surcharge des opérateurs et Amitié
VI. Polymorphisme, héritage multiple et classe abstraites
VII.Gestion des Exceptions
VIII.Modèles et patron (les Templates)
LANGAGE c++
2
Présentation et Apport du langage C++
Commentaires
Les commentaires C++ s’écrivent par //
// ceci est un commentaire c++

float x = 10.25; // déclaration et initialisation d’une variable
/* fonction élévation au cube d’un réel
entrée : un réel a
retour : le cube du réel a
*/
float cube(float a){
return a*a*a;
}
Modificateur const
les objets entiers qualifiés par const peuvent être utilisés comme taille lors de la
déclaration de tableaux statiques
Const int taille =3 ;

// déclaration d’un tableau statique
float MatRot[taille][taille] ;
float Deplacement[taille];
Déclarations des variables

La déclaration d’une variable locale à un bloc peut être placée juste avant
son utilisation. Sa portée est limitée à ce bloc
3
Déclaration et initialisation de variables :

bool var_bool = true; // variable boléenne nouveu type en C++
int i = 0; // entier
long j = 123456789; // entier long
float f = 3.1; // réel
// réel à double précision
double pi = 3.141592653589793238462643;
char c=‘a’; // caractère
« Initialisation à la mode objet » :
int i(0) ;
Long l (123456789);

Exemple :
// moyenne des éléments diagonaux d’une

//matrice carrée
#include<stdio.h>
void main(){
const int taille=3 ;
int Mat[taille][taille];
for(int i=0;i<taille;i++)
for(int j=0;j<taille;j++)
scanf("%d",&Mat[i][j]);
int som=0;
for(i =0;i<taille;i++)
som+=Mat[i][i];
float moy =(float)som/taille;
printf("la moyenne des éléments diagonaux est :
%f",moy);
}
4
les entrées sorties

Il est préférable de remplacer printf et scanf respectivement par les flux
d’entrée/sortie standards :
cout : flux standard de sortie associée à l’écran
cin : flux standard d’entrée associée au clavier
Les E/S sur ces flux se font à l’aide :
De l’opérateur d’injection << pour les sorties
De l’opérateur d’extraction >> pour les entrées
Ces flux sont définis dans le fichier entête iostream.h

Exemple1 :
#include<iostream.h>
void main(){
float a, b,x;
std::cout<<" a = " ; std::cin>>a;
std::cout<<" b= " ; std::cin>>b;
if(a==0)
if(b==0) std::cout<<"Infinités de solutions "<<std::endl;
else std::cout<<"Pas de solution"<<std::endl;
else{
x=-b/a;
std::cout<<"La solution est : "<<x<<std::endl;}
}
5
les arguments par défaut

On peut préciser la valeur par défaut pour un argument formel d’une
fonction. Cette valeur ne sera considérée que si l’argument est omis lors de
l’appel.
Les arguments par défaut doivent être toujours placés à la fin de la liste des
paramètres.
Exemple1 :
float fct (char, int = 10, float = 0.0) ;
l’appel fct ('a') sera équivalent à fct ('a', 10, 0.0) ; de même, l’appel fct ('x', 12)
sera équivalent à fct ('x', 12, 0.0).
En revanche, l’appel fct () sera illégal.
Déclaration des fonctions

L'utilisation d'une fonction sans aucune déclaration ou définition au
préalable
erreur à la compilation.
Le prototype doit figurer dans tout fichier source qui utilise cette
fonction et ne contenant pas sa définition.
Une fonction en C++ doit spécifier son type de retour, void si elle ne
retourne rien.
fct(int, int); // erreur!
void fct(int, int); //OK
int fct(void); int fct();
6
Surcharge des fonctions

En C++, des fonctions différentes peuvent avoir le même nom à la condition
que leurs signatures soient différentes(nombre et types des arguments).
Exemple :
int puissance(int x, int n) {

//calcul de xn avec x et n entiers
}
double puissance(double x, int n) {
//calcul de xn avec x flottant et n entier
}
double puissance(double x, double y) {
//calcul de xy avec x et y flottants
}

Allocation dynamique de mémoire : opérateurs new et
delete
Pour allouer ou libérer dynamiquement les espaces mémoire, les opérateurs
new et delete remplacent avantageusement malloc et free. (en effet pour
des objets, malloc n’entraîne pas l’appel des constructeurs ainsi que free
n’entraîne pas l’appel des destructeurs pour ces objets)
void main(){
int n, *p = new int; // allocation d’un seul entier
cin >> *p;
…
delete p;
…
cin>>n;
p = new int[n]; // allocation de n entiers
for(int i=0;i<n;i++)
cin>>p[i] //cin >>*(p+i);
…
delete[ ] p;
7
Les références
Une référence est un pointeur sur un objet variable de la mémoire. Elle
constitue une adresse gérée de manière interne par la machine :
hormis lors de son initialisation, toute opération exécutée sur la
référence agit directement sur l'objet référencé, et non pas sur l'adresse.
Exemple
int a = 10 , &ref_a = a , b =20 ;

…
Std::Cout << "a = " << a << " et ref_a = " << ref_a << endl ;
//Affcihe a = 10 et ref_a=10
Ref_a = b ;
Cout << "a = " << a << " et ref_a = " << ref_a << endl;
//Affcihe a = 20 et ref_a=20
Les références
une référence sur une variable est un identificateur qui joue le rôle d'un alias
(pseudo) de cette variable.
Syntaxe: type &nom_ref = var;
exemple:
int n;
int &rn=n; // rn est une référence de n
n=10;
cout<< rn; //affiche 10
Une référence ne peut être vide, elle doit toujours être initialisée lors de sa
déclaration, i.e : int &rn ; // erreur!
Il est possible de référencer des valeurs numériques, dans ce cas il faut les
déclarer comme constantes, i.e: int &rn=3; // erreur!
const int &rn=3; // OK
Les références et les pointeurs sont liés.
8
Transmission des arguments
En C++ il y a 3 méthodes de passage des variables en paramètres à une
fonction:
Passage par valeur: la valeur de la variable en paramètre est copiée
dans une variable temporaire. Les modifications opérées sur les
arguments dans la fonction n'affectent pas la valeur de la variable
passée en paramètre.
Passage par adresse: consiste à passer l'adresse d'une variable en
paramètre. Toute modification du paramètre dans la fonction affecte
directement la variable passée en paramètre.
Passage par référence: le passage par adresse présente certains
inconvénients, pour résoudre ces inconvénients, C++ introduit le
passage par référence.
En pratique, il est recommandé ( pour des raisons de performances) de
passer par référence tous les paramètres dont la copie peut prendre
beaucoup de temps.
Référence paramètre d’une fonction

Grâce aux références, C++ offre un deuxième mode de communication dit
par référence.
Exemple :
// par référence // par adresse (pointeur)

void permuter(int &x ,int &y){ void permuter(int *x ,int *y){
int temp; int temp;
temp=x; temp =*x;
x=y; *x=*y;
y=temp; *y=temp;
} }
void main(){ void main(){
int a=10,b=20; int a=10,b=20;
permuter(a,b);} permuter(&a,&b);}
9
CONCEPTS DE L’APPROCHE ORIENTÉE OBJET
Concepts de l’approche orientée objet
Objectifs
Comprendre les concepts de la programmation Objet en

C++ et définir les avantages de la POO par rapport à la
programmation procédurale
Encapsulation,
composition
Héritage,
Polymorphisme
10
Principes
L’unité de base pour construire des programmes est le concept d’Objet

qui modélise un élément du monde réel.
Chaque objet appartient à une Classe qui représente tous les objets
similaires.
La programmation objet (POO) consiste donc en la définition et

l'assemblage de briques logicielles appelées objets.
Un programme objet est alors une séquence d'instructions qui défini des
classes et qui construit, et utilise des objets de ces classes.

Encapsulation
L'encapsulation consiste à :
regrouper au sein d'une même entité les traitements (méthodes) et les
données (propriété ou attributs)
masquer les détails de réalisation en définissant une interface publique et
une implémentation cachée.
L’accès aux données uniquement par les opérations
Exemples
La classe Article est composée des membres suivants :
Membres privés : Référence, PrixUnitaire, Quantité
Membres publiques : PrixTTC, EntréeArticle, SortieArticle
La classe Compte bancaire est composée des membres suivants :
Privés : Code, Solde, dateCréation
Publiques : Verser, retirer, consulter
11
Objets et classes
1. Objet
Un objet est une représentation concrète d’une entité du monde réel. Il est
formé de deux composantes indissociables :
son état : les valeurs prises par une ou plusieurs variables
son comportement : les opérations qui lui sont applicables
Etat
l’état d’un objet est cachée aux autres objets( privé)
les variables représentant l'état d'un objet sont appelées variables
d'instance ou attributs ou données membres
chaque objet possède sa propre copie des variables d'instance et un état
courant (liste des valeurs de chaque variable d’instance)
Comportement
Caractéristique externe mise à la disposition de l’extérieur (publique)
les opérations propres à un objet sont appelées méthodes d'instance ou
fonctions membres. Ces méthodes sont invoquées par rapport à l’objet
//message généré par l’appelant à l’objet Objet_X
Objet_X . Nom_Methode(paramètres)
Classe
Une classe est un "moule" pour une catégorie d'objets structurellement

identiques. Elle permet la création d'objets basés sur ce moule.
Composition d'une classe
la définition des attributs : leurs noms et leurs types
les prototypes des méthodes : chaque prototype englobe le nom et le
type des paramètres de la méthode. Les prototypes représentent
l'interface de la classe.
la réalisation des méthodes : représente l'implémentation de la classe.
Remarques
Une classe peut contrôler l'accès à ses membres (données ou fonctions) :
Privé : accès limité à la classe
Protégé :accès limité à la classe et à ses sous-classes(héritage)
publique : accès non limité
12
La composition
Des objets peuvent être inclus les uns dans les autres. Par exemple, on peut
dire qu'une voiture est composée d'un moteur et de quatre roues :
Dans la classe Voiture dite classe composite sont incluses deux classes
composantes : Roue et Moteur. Cela signifie que tout objet, instance de la
classe Voiture disposera obligatoirement d'un moteur et de quatre roues.
Méthodes et surcharge
Il existe différents types de méthodes :
Constructeur : appelé automatiquement à la création d'un objet
initialiser un objet afin de le placer dans un état cohérent
fixe l'invariant de la classe
Destructeur : appelé automatiquement à la destruction de l'objet
permet de libérer les ressources allouées par l'objet
Accesseur(getter) : permet de consulter l'état d'un objet
Mutateur(setter): permet de modifier l' état d'un objet
La surcharge (Overloading) d'une méthode consiste à définir plusieurs
méthodes de même nom mais de signatures différentes.
13
Exemple :
C1 : Compte
Compte Code : 1
- Code : Entier DateCréation : 10/11/95
- DateCréation : Char* Solde : 15000
- Solde : Réel
C2 : Compte
Compte()
Code : 2
Compte(S : Réel)
DateCréation : 1/11/98
Compte(&C:Compte) Solde : 5000
~Compte()
GetSolde() : Réel
Verser(M : Réel) C3 : Compte
Retirer(M : Réel) Code : 3
DateCréation : 12/05/99
Solde : 35000
Héritage
L’héritage est un outil d’abstraction utilisé pour la généralisation et le
groupement. Il permet de créer de nouvelles classes à partir de classes
existantes.
1. Terminologie
Les classes dérivées sont dites : «classes filles», ou «sous classes».
Les classes d’origine sont dites : «super classes», ou « classe de base » ou
«classes parentes».
2. Remarques
Les sous classes héritent des attributs de leur super classe.
les sous classes peuvent avoir des membres qui leur sont propres.
Certaines méthodes d’une super classe peuvent être redéfinies dans les sous
classes.
Une sous classe peut avoir plusieurs super classes : on parle d'héritage
multiple
14
Exemples
Héritage simple et agrégation :
Nombre Forme Point
Entier Rationnel Réel Cercle Carré
Héritage multiple et agrégation :
Roue Véhicule à roues Véhicule électrique
Automobile électrique

Polymorphisme
Objet polymorphe : Objet pouvant prendre plusieurs

formes Forme
Géométrique
Polymorphisme = mécanisme qui consiste à donner un même
nom à une action différente à chaque niveau de la
hiérarchie.
Dessiner()
si le compilateur peut résoudre le problème de savoir de
quelle fonction il s'agit, on parle de polymorphisme
statique,
En revanche si cette résolution est reportée au moment de
l'exécution, et est fonction du type d'objet auquel est
appliqué cette action, on parle de polymorphisme Cercle Rectangle
dynamique.
Dessiner() Dessiner()
15
Exemples
Chaine.h
# include <iostream>
using namespace std;
class chaine {
// std::string s;
string s;
int i;
public :
chaine();
bool boolean();
void afficher();
};

Exemples Chaine.cpp
# include <string.h>
#include "chaine.h"
void chaine::afficher(){
std::cout<< s; }
chaine::chaine(){
std::cout<< "entrer une chaine de caractère :";
getline(std::cin, s); ////saisir une chaine de caractères
// std::cin>>s; //l'espace non compté
i=s.size();
std::cout<<"nombre de caractères de la chaine est :"<< i <<std::endl;
boolean(); }
bool chaine::boolean(){
std::cout<< "entrer un nombre :";
std::cin >>i;
if (i>0)return std::cout<< true<<std::endl;
else return std::cout<<false<<endl; }
main (){
chaine ch;
ch.afficher(); }
16
CLASSES ET OBJETS
Classes et Objets
Définition d'une classe
La déclaration d'une classe consiste à décrire ses membres

(membres données et prototypes de ses fonctions membres)
groupés en sections. Chaque section est étiquetée par l'un des
mots clés : private, public, ou protected, qui précisent le
mode d'accès aux membres contenus dans la section.
♦ private: accès autorisé seulement par les fonction membres
♦ public: accès libre
♦protected: accès autorisé seulement dans les fonctions

membres de la classe et de ses dérivées (voir héritage).
Pour déclarer une classe, on utilise le mot clé class.
17
Classes et Objets
Déclaration
Une classe est déclarée avec le mot-clé class par :
class Nomclasse{
private : // partie accessible uniquement aux fonctions
// membres de la classe et aux fonctions amies
…
protected : // partie accessible aux fonctions membres et
// amies de la classe ainsi qu'aux classes dérivées
…
public : // accessible à tout utilisateur d'une instance de la classe
} ;
Remarques
• Par défaut, les membres d’une classe sont privés.
• Les expressions private, public et protected peuvent apparaître un
nombre quelconque de fois dans une classe.
Classes et Objets
Exemple
class Point
{
private:
int x; Données membres ( ou attributs) privés
int y;
public:
void initialise(int,int);
Méthodes public
void deplace(int,int);
void affiche();
} ;
Attention au point virgule après la définition d'une classe
18
Classes et Objets
Exemple : déclaration de la classe Point
// fichier entête Point.h

class Point{
int x , y ;
char nom ;
public:
void initialiser( int , int , char ) ;
void deplacer( int , int ) ;
void afficher( ) ;
void masquer( );
float distance(Point);
char getNom( );
} ;
Classes et Objets
La mention d'accès par défaut dans une classe est

private:
class Point
{
int x;
int y;
public: // membres publiques
……};
La définition d'une classe consiste à définir les
prototypes des fonctions membres. Pour les définir on
utilise l'opérateur de portée (::) :
type nom_class::fct(arguments) {……}
19
Classes et Objets
Définition des fonctions membres d’une classe
les fonctions membres d’une classe sont définies de la façon suivante :
TypeFonction NomClasse :: NomFonction( ListParamètre){

//Déclarations
//Actions
}
L’opérateur :: est appelé l’opérateur de résolution de portée.
Classes et Objets
Exemple :Implémentation de la classe Point
//fichierPoint.cpp
#include<math.h>
#include "Point.h«
void Point :: initialiser(int px, int py, char pnom)

{ x = px ; y = py ; nom = pnom ;}
void Point :: afficher( ){ //affichage

cout<<"x="<<x<< "y="<<y<< "nom ="<<nom<<endl;}
void Point :: masquer(){

x=0;y=0; nom='o'; afficher();}
void Point :: deplacer(int dx,int dy){

masquer(); x = x+dx; y = y+dy; afficher();}
float Point :: distance(Point M){

int dx=x+M.x, dy=y+M.y ;
return sqrt(dx*dx+dy*dy);}
char Point :: getNom(){return nom ; }
20
Classes et Objets
Utilisation d'une classe

Un objet (ou instance) nom_objet d'une classe, nommée nom_classe
est déclaré comme une variable de type nom_classe :
nom_classe nom_objet;
On peut accéder à n'importe quel membre publique d'une classe
en utilisant l'opérateur (.) (point). Par exemple:
Point A;
……
A.initialise(10,12); // appel de la fct membre initailise de la classe 'Point'
//Cout<<'' l'abscisse du point A est'' <<A.x<<endl; //erreur car x est un attribut privé!!
A.affiche();
Classes et Objets
Instanciation
La déclaration d’une instance (objet) d ’une classe donnée se fait par :
NomClasse NomObjet ; //Variable Objet statique
NomClasse *NomPointeurObjet //Pointeur sur un objet
Accès aux membres
L'accès aux membres d'un objet, sous réserve qu'il est possible, est réalisé comme
pour le cas des structures par les opérateurs . et -> :
// cas d'un objet

NomObjet.NomFct ( param_eff ) //Appel à une fonction membre
NomObjet.NomAttribut //Accès à un attribut membre
// cas d'un pointeur sur un objet
NomPointeurObjet->NomFct(param_eff)
NomPointeurObjet->NomAttribut
21
Classes et Objets
Exemple :
#include<stdlib.h> getch();
#include<conio.h> p2= new Point;
#include<stdio.h> p2->initialiser(15,20,'N');
#include"Point.h"
p2->afficher();
main(){
getch();
Point p1,*p2;
float d;
system("cls");
p1.initialiser(30,15,'M'); d=p1.distance(*p2);
p1.afficher(); printf("la distance de %c à %c est
getch(); %f\n",p1.getNom(),p2->getNom(),d);
p1.masquer(); getch();
getch(); delete p2;
p1.deplacer(10,0); }
Classes et Objets
Constructeur/Destructeur
C++ permet l'utilisation de fonctions membres dites
constructeurs et destructeur qui sont implicitement appelées
respectivement lors de la création et la destruction d'un objet.
Le(s) constructeur(s) sont des fonctions membres qui portent le

même nom que leur classe. Ces constructeurs sont appelés après
l'allocation de l'espace mémoire destiné à l'objet.
Un constructeur peut être surchargé et avoir des arguments par
défaut.
22
Classes et Objets
Les constructeurs
Un constructeur d'une classe est une fonction membre spéciale qui :

porte le même nom que la classe
est sans type de retour et par suite ne contient pas d'instruction return
Une classe peut avoir plusieurs constructeurs de signatures différentes
(surcharge) :
Exemples :
Ou bien Ou bien
class Point class Point class Point{
{ { int x,y;
int x,y; int x,y; public :
public : public : Point(int =0,int =0);
Point(int a,int b){ Point(int a=0,int b=0){ …
x=a;y=b;} } ;
x=a;y=b;
Point(int a){x=a;y=0;} } Point::Point(int a,int b)
Point(){x=y=0;} … {
… } ; x=a;y=b;
} ;
}
Classes et Objets
Constructeur par copie

le constructeur par copie d'une classe C est un constructeur ayant un paramètre
de type const C & (référence sur un objet constant de la classe C) :
nomclasse( const nomclasse &ref ) ;
le constructeur par copie est appelé dans les cas suivants :

• Initialiser un objet (à sa déclaration) en copiant d'un autre existant .
• Lorsqu’un objet est passé comme paramètre par valeur à une fonction ou
rendu comme résultat par valeur d'une fonction
Remarque
• Si une classe ne contient pas de constructeur par copie, le compilateur
synthétise un constructeur par copie automatique. Celui-ci recopie bit par
bit de l’objet source dans l’objet destination.
23
Classes et Objets
Destructeur
Le destructeur est une fonction membre systématiquement exécutée "à la fin

de la vie" d’une instance.
Un destructeur porte le même nom que la classe précédé d'un tilde (~), et n'a
pas de paramètres ni de valeur retournée. :
NomClasse::~NomClasse( ){
//Actions recquises }
Classes et Objets
Exercice: définir une classe Segment ayant deux constructeurs:
class class Segment {

public:
Segment();
Segment(const Segment &);// constructeur par copie
~Segment();
};
• Définir le constructeur de la classe

• Définir un constructeur par copie de la classe Segment
• Définir un destructeur de la classe Segment
24
Classes et Objets
class Segment{ Segment::Segment(){

public: cout<<"constructeur d'un
Segment(); // constructeur Segment"<<endl;
Segment(const Segment &); }
//constructeur par copié Segment::Segment(const Segment &sg){
~Segment(); cout<<"constructeur d'un
Segment par copie"<<endl;
};
}
Segment::~Segment(){
cout<<"destructeur d'un
Segment"<<endl;
}
Segment &fonct(Segment &s1, Segment
main(){ &s2) {
Segment s1,s2; return s1;
s1=fonct(s1,s2); }
}
25

Cours POO C++ Partie I

Transféré par

Droits d'auteur :

Formats disponibles

Cours POO C++ Partie I

Transféré par

Informations du document

Description originale:

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 C++ Partie I

Transféré par

Droits d'auteur :

Formats disponibles

Université Sidi Mohamed Ben Abdallah

Ecole Nationale des Sciences Appliquées

S. EL GAROUANI ENSA Fès 2017-2018

• Maîtriser les bases du langage C++

• Comprendre les concepts de la programmation Objet en C++ et

• Encapsulation, Composition, Héritage, polymorphisme

• Mettre en pratique la gestion des exceptions

S. EL GAROUANI ENSA Fès 2017-2018 2

I. Présentation des apports de C++

S. EL GAROUANI ENSA Fès 2017-2018 3

S. EL GAROUANI ENSA Fès 2017-2018

// ceci est un commentaire c++

S. EL GAROUANI ENSA Fès 2017-2018 5

Présentation et Apport du langage C++

Const int taille =3 ;

Déclarations des variables

S. EL GAROUANI ENSA Fès 2017-2018 6

Déclaration et initialisation de variables :

S. EL GAROUANI ENSA Fès 2017-2018 7

Présentation et Apport du langage C++

// moyenne des éléments diagonaux d’une

S. EL GAROUANI ENSA Fès 2017-2018 8

les entrées sorties

S. EL GAROUANI ENSA Fès 2017-2018 9

Présentation et Apport du langage C++

S. EL GAROUANI ENSA Fès 2017-2018 10

les arguments par défaut

float fct (char, int = 10, float = 0.0) ;

S. EL GAROUANI ENSA Fès 2017-2018 11

Présentation et Apport du langage C++

Déclaration des fonctions

int fct(void); int fct();

S. EL GAROUANI ENSA Fès 2017-2018 12

Surcharge des fonctions

int puissance(int x, int n) {

S. EL GAROUANI ENSA Fès 2017-2018 13

Présentation et Apport du langage C++

S. EL GAROUANI ENSA Fès 2017-2018 14

int a = 10 , &ref_a = a , b =20 ;

S. EL GAROUANI ENSA Fès 2017-2018 15

Présentation et Apport du langage C++

S. EL GAROUANI ENSA Fès 2017-2018 16

S. EL GAROUANI ENSA Fès 2017-2018 17

Présentation et Apport du langage C++

Référence paramètre d’une fonction

// par référence // par adresse (pointeur)

S. EL GAROUANI ENSA Fès 2017-2018 18

S. EL GAROUANI ENSA Fès 2017-2018

Concepts de l’approche orientée objet

Comprendre les concepts de la programmation Objet en

S. EL GAROUANI ENSA Fès 2017-2018 20

L’unité de base pour construire des programmes est le concept d’Objet

La programmation objet (POO) consiste donc en la définition et

S. EL GAROUANI ENSA Fès 2017-2018 21

Concepts de l’approche orientée objet

S. EL GAROUANI ENSA Fès 2017-2018 22

S. EL GAROUANI ENSA Fès 2017-2018 23

Concepts de l’approche orientée objet