SlideShare une entreprise Scribd logo
1  sur  56
Télécharger pour lire hors ligne
Programmation Orientée Objets en C++
R. Ben Abbou & A. Zahi
FSTF, Fez, Maroc
Programmation Orientée Objets
Chapitre 3
Classes Objets
Plan du Chapitre
 Introduction
 Ecarts de C++ par rapport à C ANSI
 Apports de C++
Plan du chapitre
 Structures
 Classes
 Constructeur & Destructeur
 Membres statiques
 Surdéfinition des fonctions
 Fonctions amies
Les structures
 En C les structures contiennent uniquement des
données
 Exemple
Struct point {
int x;
int y;
};
 En C++ les structures peuvent contenir des fonctions
 Exemple Struct point {
int x;
int y;
};
Les structures
 L’accès aux champs de la structure peut s’effectuer
directement ou via les fonctions
 Exemple
Point a, b;
a.x=10;
équivalent à a.initialise(10,20)
a.y=20;
#include<iostream.h>
Using namaspace std;
struct point {
int x; int y;
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
}
int main()
{
point a,b;
a.initialise (10,20);
a.affiche();
a.deplace (5,5);
a.affiche();
b.x=1;
b.y=1;
b.affiche();
return 0;
}
Les structures
 Exemple en C++
Classes
 La notion de classe permet de :
 Généraliser la notion de type (structure)
 Réunir données et traitement dans la même entité
 Intégrer un certain niveau de sécurité
 Les données sont, généralement, protégées: seules les méthodes de
la classe peuvent y accéder
#include<iostream.h>
Using namaspace std;
class point {
private: // espace privé
int x; int y;
public: // espace publique
void initialise(int,int);
void deplace(int,int);
void affiche();
};
 Exemple
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y
<<"n";
}
Classes
 Droit d’accès aux membres
 Trois modes d’accès aux membres d’une classe:
 Public : accès permis à partir de n’importe quel point du programme
 Private
• Seules les méthodes de la classe peuvent accéder au membre "privé"
• C’est la mode par défaut
 Protected : sémantique liée à l’héritage
Classes
 Droit d’accès aux membres
 Les modes d’accès concernent les membres données et les méthodes
 Une fonction membre privée ne peut être appelée qu’à partir d’une autre
fonction membre
 Les membres données peuvent être "public" mais c’est déconseillé, cela
contredit le concept d’encapsulation
 La structure en C++ est un cas particulier de classe où tous les membres
sont public
Classes
 Droit d’accès aux membres
 Les mots clés public, private et protected peuvent figurer
plusieurs fois lors de la déclaration de la classe
 Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
private: // espace privé
int x; int y;
public: // espace publique
void initialise(int,int);
void deplace(int,int);
void affiche();
private: // espace privé
int calculer(int);
};
Classes
 Définition des fonctions membres
 Les fonctions membres sont définies de la même manière que
les fonctions ordinaires
 Les fonctions membres peuvent accéder aux membres
données (sans les passer en paramètre)
 La fonction membre est indexée (opérateur de porté ::) par le
nom de sa classe
 Définition des fonctions membres
 Syntaxe
 Exemple
void point::deplace(int dx,int dy)
{
x+=dx;
y+=dy;
}
void point:: affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
};
Classes
Type nom_classe :: nom_fonction (type param,…)
{
corps de la fonction
}
 Instanciation de classes
 Création de variables de type classes objets
 Se fait par une simple déclaration :
 Objets statiques :
nom_class ob1, ob2; // objets statiques
 Objets dynamiques nécessité d’allouer de la mémoire
nom_class *ob1, *ob2 // objets dynamiques
ob1 = new nom_class ; // allocation de la mémoire
ob2 = new nom_class ; // allocation de la mémoire
Classes
 Instanciation de classes  Affectation d’objets
nom_class ob1, ob2;
ob2 = ob1;
 Copie les valeurs des membres données de ob1 dans ob2
 Attention!! Si l’objet contient des membres données
dynamiques
Risque d’incohérence
Classes
 Instanciation de classes  Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
int x; int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
}
Int main() {
point a,b;
a.initialise (10,20);
a.affiche();
b=a;
b.affiche();
b.deplace(3,3);
b.affiche();
a.affiche();
return 0;
}
 Membre données dynamique dans une classe
class nom_class {
typ * m ;
.
.
.
};
 Allocation lors de l’initialisation
 Partage de l’espace dans la cas d’une affectation entre deux
objets
nom_class obj1, obj2;
Obj1 = obj2;
Obj1 et obj2 partagent le même espace de l’attribut m,
Classes
 Instanciation de classes  Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
int *x; int *y; // membres dynamiques
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
X= newt int; y = new int; //allocation de la
mémoire
*x=abs; *y=ord;
}
void point::deplace(int dx,int dy)
{
*x+=dx; *y+=dy;
}
void point::affiche()
{
cout << "position :" <<*x <<"," <<*y <<"n";
}
int main() {
point a,b;
a.initialise (10,20);
a.affiche();
b=a;
b.affiche();
b.deplace(3,3);
a.affiche(); //a aussi de déplace
return 0;
}
 Le pointeur this
 this pointeur qui pointe sur l’objet en cours
 Crée dans les fonctions membres
 Exemple
Classes
#include<iostream>
using namespace std;
class point { int x;
int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche() {
cout << this-> x;
cout << this-> y;
};
Constructeur / Destructeur
 Deux fonctions membres spéciales
 Constructeur : initialise les objets de la classe
 Destructeur : détruit les objets de la classe
 Toutes les deux sont facultatives
 Initialise les membres données de l’objet lors de sa
déclaration par:
 Les valeurs passées en paramètres
 Un autre objet existant de la même classe (constructeur de recopie)
 Alloue de la mémoire si l’objet contient une partie dynamique
Constructeur Rôle
 Porte le nom de la classe
 N’a pas de type de retour
 Peut avoir des paramètres
 Est facultatif S’il n’est pas défini le compilateur génère
un constructeur par défaut
Constructeur Caractéristiques
 Syntaxe
nom_classe::nom_classe([param1,…]) {…}
 Peut être surdéfini
nom_classe::nom_classe(param1,param2) {…}//avec deux paramètres
nom_classe::nom_classe(param1) {…} // un seul paramètre
nom_classe::nom_classe() {…} // sans paramètres
Constructeur Caractéristiques
 Appelé implicitement lors de la déclaration
 Objets statiques
nom_classe ob1(val1,val2);
nom_classe ob2(val);
nom_classe ob3;
 Objets dynamiques
nom_classe *ob4; ob4 =new nom_classe (val1,val2)
nom_classe *ob5; ob5 =new nom_classe (val)
nom_classe *ob6; ob6 =new nom_classe ()
Constructeur Caractéristiques
#include<iostream.h>
class point {
int x;
int y;
public:
point(int,int); // un constructeur à deux paramètres
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n"; }
Constructeur Exemple
void main()
{
point a(10,20),b(30,30);
point c; // erreur
a.affiche();
a.deplace (5,5);
a.affiche();
b.affiche();
}
Constructeur membres données dynamiques
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
int main()
{
float t1[]={1,1,1}, t2[]={2,2,2,2};
dvecteur V1(3,t1),V2(4,t2);
V2 = V1;
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}
Constructeur de recopie Rôle
 Initialise l’objet lors de sa déclaration par un autre objet
Mamouni
Mustapha
C67965
Mamouni
Mustapha
C67965
P_existant P_nouveau
 Porte le nom de la classe
 N’a pas de type de retour
 A un seul paramètre : une référence à un objet
 Est facultatif S’il n’est pas défini le compilateur génère
un constructeur par défaut
 Ne peut pas être surdéfini
Constructeur de recopie Caractéristiques
 Syntaxe
nomclasse :: nomclasse (nomclasse&) { …}
 Est appelé implicitement lors des situations suivantes:
 Déclaration initialisation
nomclasse nouveau_objet=objet_existant;
 Passage par valeur d’un objet en paramètre
f(nomclasse objet)
 Retour d’un objet déjà existant par une fonction
return objet_existant;
Constructeur de recopie Caractéristiques
#include<iostream.h>
class point {
int x;
int y;
public:
point(int,int); // un constructeur à deux paramètres
point(const point&); // un constructeur à deux paramètres
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n"; }
Constructeur Exemple
point::point(const point &p)
{
x=p.x; y=p.y;
}
void f(point p)
{
p.affiche();
}
point g()
{
point h(1,1);
return h;
}
void main()
{
point a(10,20);
point c=a;
c.affiche();
c.deplace (5,5);
cout << "ici la fonction f" << endl;
f(c);
cout << "ici la fonction g" << endl;
c = g();
c.affiche();
return 0;
}
Constructeur de recopie membres données
dynamiques
 Risque d’incohérence
 Les deux objets (initial et la copie) se partageront une
même zone mémoire
 La modification des données de l’un affectera l’autre
Constructeur membres données dynamiques
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
dvecteur(dvecteur&);
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
dvecteur::dvecteur (dvecteur& vect)
{
dim=vect.dim;
V= new float[dim];
for(int i=0;i<dim;i++)
V[i]=vect.V[i];
}
int main()
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
dvecteur V2 = V1;
dvecteur V3(V1);
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}
Destructeur Rôle
 Libération des ressources de l’objet à la fin de son
utilisation
 Libération de la zone mémoire allouée par un
constructeur
 Porte le nom de la classe précédé par le caractère ~
 N’a pas de paramètres
 N’a pas de type de retour
 Ne peut pas être surdéfini
Destructeur Caractéristiques
Destructeur Exemple
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
dvecteur(dvecteur&);
~dvecteur();
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
dvecteur::dvecteur (dvecteur& vect)
{
dim=vect.dim;
V= new float[dim];
for(int i=0;i<dim;i++)
V[i]=vect.V[i];
}
dvecteur::~dvecteur ()
{
dim=0;
delete V;
cout<<"n Appel du destructeurn";
}
void scenario(float d)
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
V1.afficher(); V1.decaler(d);
V1.afficher();
}
int main()
{
int d;
for(d=1;d<4;d++)
scenario(d);
return 0;
}
Classe d’allocation static
 Stockage dans la zone statique
 Durée de vie permanente, égale à celle du programme
 Même portée que les variables automatique
 Initialisation au moment de la compilation, initialisation
par défaut à 0
 Syntaxe
static float x;
#include <stdio.h>
void fonct()
{
static int x=0;
int y=0;
printf("x = %d, y = %dn",x++, y++);
}
int main()
{
int i ;
for (i=0;i <10; i++)
{
printf(" iteration = %d ", i);
fonct();
}
return 0;
}
Classe d’allocation static Exemple
 Applicable aux méthodes et aux attributs
 Propriété indépendante de tous les objets (propriété de
la classe)
Classe d’allocation static
Membres données static
 Lors de la déclaration des objets chaque objet possède
ses propres membres données
 Exemple
Ob1 Ob2
10
15 30
20
Membres données static
 Un membre static est partagé par tous les objets de la classe
 Syntaxe Le membre est précédé par le mot clé static lors de
la déclaration de la classe
static type nom_var;
 L’initialisation n’est pas automatique
Type class_name::ident = 0;
Ob1 Ob2
10
15 30
20
Ob3
Membres données Static Exemple
#include<iostream.h>
class point {
static int nb;
int x;
int y;
public:
point(int,int);
void deplace(int,int);
void affiche();
};
int point::nb=0;
point::point(int abs,int ord)
{
nb++;
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx;
y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"nombre
d'objets" << nb <<"n";
}
void main()
{
point a(10,20);
a.affiche();
a.deplace (5,5);
a.affiche();
point b(30,30);
b.affiche();
}
Fonctions membres static
 Sont indépendantes de tous les objets de la classe
 Agissent sur des membres static
 Sont appelées sans référence à un objet référencées
directement par le nom de la classe
nom_classe::fonct_static(…);
Fonctions membres static
 Peuvent être appelées avant la création de tout objet
 Syntaxe
class nom_classe {
….
public:
…
static type fonct_static(….);
};
#include<iostream.h>
class point {
static int nb;
int x;
int y;
public:
point(int,int);
void deplace(int,int);
void affiche();
static void compteur();
};
int point::nb=0;
point::point(int abs,int ord)
{
nb++;
x=abs; y=ord;
}
void point::compteur()
{
cout <<"n nombre de points :"<<nb;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y
<<"nombre d'objets" << nb <<"n";
}
void senario(int i)
{
point a(i,i);
a.affiche();
}
void main()
{
point a(i,i);
a.affiche();
point::compteur();
for(int i=0;i<4;i++)
senario(i);
return 0;
}
Fonctions membres static Exemple
Surdéfinition des fonctions membres
 La surdéfinition peut être appliquée aux fonctions
membres d’une classe
 Plusieurs fonctions membres portent le même nom mais diffèrent
dans le contenu selon le type et/ou le nombre de paramètres
 Sémantiquement ces fonctions font la même action (ex afficher)
 Le compilateur choisit la fonction à invoquer selon les paramètres
effectifs
 Plus de lisibilité : pas besoin de chercher plusieurs identificateurs
pour la même action
#include<iostream.h>
class point {
int x;
int y;
public:
void initialise(int,int);
void initialise(int);
void initialise ();
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int
ord)
{
x=abs;
y=ord;
}
void point::initialise(int c)
{
x=c;
y=c;
}
void point::initialise()
{
x=100;
y=100;
}
Surdéfinition des fonctions membres
Paramètres par défaut des fonctions membres
 Une fonction membre peut attribuer des valeurs par
défaut à certains paramètres omis lors de l’appel
 Seuls les derniers paramètres peuvent avoir des valeurs
par défaut
 ≠ surdéfinition des fonctions Une seule fonction
 !!! Attention risque d’ambiguïté avec la surdéfinition
class point {
int x;
int y;
public:
void initialise(int =10,int =10);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs;
y=ord;
}
Paramètres par défaut des fonctions membres Exemple
Fonctions amies
 Une fonction amie est une fonction non membre d’une classe
et possédant le droit d’accès aux membres privés de ses
objets.
 Intérêt : résoudre certains problèmes de communication entre
objets
 Fonction qui a besoin, dans certains cas, d’accéder aux
membres privés de deux classes différentes
 Attention !! : Violation du concept d’encapsulation
 L’amitié est déclarée par le mot clé friend
Fonctions amies
 Fonction indépendante et amie d’une classe
 Syntaxe
class A {
…
public:
…
friend type_retour fonct_amie(…);
…
};
// définition de la fonction amie
type_retour fonct_amie(…)
{
…
}
Fonctions amies
 Remarque
// Attention !!!! Fausse définition
type_retour A::fonct_amie(…)
{
…
}
Fonctions amies
 Fonction membre d’une classe A et amie d’une ou plusieurs classes
 Syntaxe
class A {
…
public:
…
type_retour fonct_amie(…);
…
};
class B {
…
public:
…
friend type_retour A::fonct_amie(…);
};
Fonctions amies
 Toutes les fonctions membres d’une classe A sont amies d’une
autre classe B
 Syntaxe
class A {
…
public:
…
};
class B {
…
public:
…
friend class A; // les fonctions membres sont amies de classe B
};
Fonctions amies  Exemple1
class point {
int x;
int y;
public:
point(int,int);
void deplace(int,int);
friend int complexe::coincide(point&);
void affiche();
};
class complexe {
int x;
int y;
public:
complexe(int,int);
int coincide(point&);
void affiche();
…
};
class point {
int x;
int y;
public:
point(int,int);
void deplace(int,int);
friend int coincide(complexe&, point&);
void affiche();
};
class complexe {
int x;
int y;
public:
complexe(int,int);
int coincide(point&);
friend int coincide(complexe&,point&);
void affiche();
…
};
Fonctions amies  Exemple2

Contenu connexe

Similaire à POO-chapitre3.pptx

Formation C# - Cours 3 - Programmation objet
Formation C# - Cours 3 - Programmation objetFormation C# - Cours 3 - Programmation objet
Formation C# - Cours 3 - Programmation objetkemenaran
 
Chapitre 2 classe et objet
Chapitre 2   classe et objetChapitre 2   classe et objet
Chapitre 2 classe et objetAmir Souissi
 
Deuxième partie.pptx
Deuxième partie.pptxDeuxième partie.pptx
Deuxième partie.pptxSafaeLhr1
 
Chapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeChapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeAmir Souissi
 
Cpp2 : classes et objets
Cpp2 : classes et objetsCpp2 : classes et objets
Cpp2 : classes et objetsAbdoulaye Dieng
 
Héritage dans cpp dev informatique ingenierie
Héritage dans cpp dev informatique ingenierieHéritage dans cpp dev informatique ingenierie
Héritage dans cpp dev informatique ingenierieMohammedAmineELHARCH1
 
Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Amel Morchdi
 
Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Amel Morchdi
 
chapitre4-HeritageetPolymorphisme.pdf
chapitre4-HeritageetPolymorphisme.pdfchapitre4-HeritageetPolymorphisme.pdf
chapitre4-HeritageetPolymorphisme.pdfMoez Moezm
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++coursuniv
 
Memojava 100604104941-phpapp02
Memojava 100604104941-phpapp02Memojava 100604104941-phpapp02
Memojava 100604104941-phpapp02Rahma Boufalgha
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneMicrosoft
 
Cours java smi 2007 2008
Cours java smi 2007 2008Cours java smi 2007 2008
Cours java smi 2007 2008Khalil Lechheb
 
Cours java smi 2007 2008
Cours java smi 2007 2008Cours java smi 2007 2008
Cours java smi 2007 2008Khalil Lechheb
 
Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Laurent BUNIET
 

Similaire à POO-chapitre3.pptx (20)

Formation C# - Cours 3 - Programmation objet
Formation C# - Cours 3 - Programmation objetFormation C# - Cours 3 - Programmation objet
Formation C# - Cours 3 - Programmation objet
 
Chapitre 2 classe et objet
Chapitre 2   classe et objetChapitre 2   classe et objet
Chapitre 2 classe et objet
 
Deuxième partie.pptx
Deuxième partie.pptxDeuxième partie.pptx
Deuxième partie.pptx
 
Chapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeChapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphisme
 
Memo java
Memo javaMemo java
Memo java
 
Cpp2 : classes et objets
Cpp2 : classes et objetsCpp2 : classes et objets
Cpp2 : classes et objets
 
Héritage dans cpp dev informatique ingenierie
Héritage dans cpp dev informatique ingenierieHéritage dans cpp dev informatique ingenierie
Héritage dans cpp dev informatique ingenierie
 
Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++
 
Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++Chapitre 2 poo classe objet c++
Chapitre 2 poo classe objet c++
 
POO-JAVA-partie-1.pdf
POO-JAVA-partie-1.pdfPOO-JAVA-partie-1.pdf
POO-JAVA-partie-1.pdf
 
chapitre4-HeritageetPolymorphisme.pdf
chapitre4-HeritageetPolymorphisme.pdfchapitre4-HeritageetPolymorphisme.pdf
chapitre4-HeritageetPolymorphisme.pdf
 
Pensez objets avec java
Pensez objets avec javaPensez objets avec java
Pensez objets avec java
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++
 
POO
POOPOO
POO
 
Memojava 100604104941-phpapp02
Memojava 100604104941-phpapp02Memojava 100604104941-phpapp02
Memojava 100604104941-phpapp02
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ Moderne
 
Cours java smi 2007 2008
Cours java smi 2007 2008Cours java smi 2007 2008
Cours java smi 2007 2008
 
Cours java smi 2007 2008
Cours java smi 2007 2008Cours java smi 2007 2008
Cours java smi 2007 2008
 
Ch09
Ch09Ch09
Ch09
 
Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1
 

POO-chapitre3.pptx

  • 1. Programmation Orientée Objets en C++ R. Ben Abbou & A. Zahi FSTF, Fez, Maroc
  • 3. Plan du Chapitre  Introduction  Ecarts de C++ par rapport à C ANSI  Apports de C++
  • 4. Plan du chapitre  Structures  Classes  Constructeur & Destructeur  Membres statiques  Surdéfinition des fonctions  Fonctions amies
  • 5. Les structures  En C les structures contiennent uniquement des données  Exemple Struct point { int x; int y; };  En C++ les structures peuvent contenir des fonctions  Exemple Struct point { int x; int y; };
  • 6. Les structures  L’accès aux champs de la structure peut s’effectuer directement ou via les fonctions  Exemple Point a, b; a.x=10; équivalent à a.initialise(10,20) a.y=20;
  • 7. #include<iostream.h> Using namaspace std; struct point { int x; int y; void initialise(int,int); void deplace(int,int); void affiche(); }; void point::initialise(int abs,int ord) { x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"n"; } int main() { point a,b; a.initialise (10,20); a.affiche(); a.deplace (5,5); a.affiche(); b.x=1; b.y=1; b.affiche(); return 0; } Les structures  Exemple en C++
  • 8. Classes  La notion de classe permet de :  Généraliser la notion de type (structure)  Réunir données et traitement dans la même entité  Intégrer un certain niveau de sécurité  Les données sont, généralement, protégées: seules les méthodes de la classe peuvent y accéder
  • 9. #include<iostream.h> Using namaspace std; class point { private: // espace privé int x; int y; public: // espace publique void initialise(int,int); void deplace(int,int); void affiche(); };  Exemple void point::initialise(int abs,int ord) { x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"n"; } Classes
  • 10.  Droit d’accès aux membres  Trois modes d’accès aux membres d’une classe:  Public : accès permis à partir de n’importe quel point du programme  Private • Seules les méthodes de la classe peuvent accéder au membre "privé" • C’est la mode par défaut  Protected : sémantique liée à l’héritage Classes
  • 11.  Droit d’accès aux membres  Les modes d’accès concernent les membres données et les méthodes  Une fonction membre privée ne peut être appelée qu’à partir d’une autre fonction membre  Les membres données peuvent être "public" mais c’est déconseillé, cela contredit le concept d’encapsulation  La structure en C++ est un cas particulier de classe où tous les membres sont public Classes
  • 12.  Droit d’accès aux membres  Les mots clés public, private et protected peuvent figurer plusieurs fois lors de la déclaration de la classe  Exemple Classes #include<iostream.h> Using namaspace std; class point { private: // espace privé int x; int y; public: // espace publique void initialise(int,int); void deplace(int,int); void affiche(); private: // espace privé int calculer(int); };
  • 13. Classes  Définition des fonctions membres  Les fonctions membres sont définies de la même manière que les fonctions ordinaires  Les fonctions membres peuvent accéder aux membres données (sans les passer en paramètre)  La fonction membre est indexée (opérateur de porté ::) par le nom de sa classe
  • 14.  Définition des fonctions membres  Syntaxe  Exemple void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point:: affiche() { cout << "position :" <<x <<"," <<y <<"n"; }; Classes Type nom_classe :: nom_fonction (type param,…) { corps de la fonction }
  • 15.  Instanciation de classes  Création de variables de type classes objets  Se fait par une simple déclaration :  Objets statiques : nom_class ob1, ob2; // objets statiques  Objets dynamiques nécessité d’allouer de la mémoire nom_class *ob1, *ob2 // objets dynamiques ob1 = new nom_class ; // allocation de la mémoire ob2 = new nom_class ; // allocation de la mémoire Classes
  • 16.  Instanciation de classes  Affectation d’objets nom_class ob1, ob2; ob2 = ob1;  Copie les valeurs des membres données de ob1 dans ob2  Attention!! Si l’objet contient des membres données dynamiques Risque d’incohérence Classes
  • 17.  Instanciation de classes  Exemple Classes #include<iostream.h> Using namaspace std; class point { int x; int y; public: void initialise(int,int); void deplace(int,int); void affiche(); }; void point::initialise(int abs,int ord) { x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"n"; } Int main() { point a,b; a.initialise (10,20); a.affiche(); b=a; b.affiche(); b.deplace(3,3); b.affiche(); a.affiche(); return 0; }
  • 18.  Membre données dynamique dans une classe class nom_class { typ * m ; . . . };  Allocation lors de l’initialisation  Partage de l’espace dans la cas d’une affectation entre deux objets nom_class obj1, obj2; Obj1 = obj2; Obj1 et obj2 partagent le même espace de l’attribut m, Classes
  • 19.  Instanciation de classes  Exemple Classes #include<iostream.h> Using namaspace std; class point { int *x; int *y; // membres dynamiques public: void initialise(int,int); void deplace(int,int); void affiche(); }; void point::initialise(int abs,int ord) { X= newt int; y = new int; //allocation de la mémoire *x=abs; *y=ord; } void point::deplace(int dx,int dy) { *x+=dx; *y+=dy; } void point::affiche() { cout << "position :" <<*x <<"," <<*y <<"n"; } int main() { point a,b; a.initialise (10,20); a.affiche(); b=a; b.affiche(); b.deplace(3,3); a.affiche(); //a aussi de déplace return 0; }
  • 20.  Le pointeur this  this pointeur qui pointe sur l’objet en cours  Crée dans les fonctions membres  Exemple Classes #include<iostream> using namespace std; class point { int x; int y; public: void initialise(int,int); void deplace(int,int); void affiche() { cout << this-> x; cout << this-> y; };
  • 21. Constructeur / Destructeur  Deux fonctions membres spéciales  Constructeur : initialise les objets de la classe  Destructeur : détruit les objets de la classe  Toutes les deux sont facultatives
  • 22.  Initialise les membres données de l’objet lors de sa déclaration par:  Les valeurs passées en paramètres  Un autre objet existant de la même classe (constructeur de recopie)  Alloue de la mémoire si l’objet contient une partie dynamique Constructeur Rôle
  • 23.  Porte le nom de la classe  N’a pas de type de retour  Peut avoir des paramètres  Est facultatif S’il n’est pas défini le compilateur génère un constructeur par défaut Constructeur Caractéristiques
  • 24.  Syntaxe nom_classe::nom_classe([param1,…]) {…}  Peut être surdéfini nom_classe::nom_classe(param1,param2) {…}//avec deux paramètres nom_classe::nom_classe(param1) {…} // un seul paramètre nom_classe::nom_classe() {…} // sans paramètres Constructeur Caractéristiques
  • 25.  Appelé implicitement lors de la déclaration  Objets statiques nom_classe ob1(val1,val2); nom_classe ob2(val); nom_classe ob3;  Objets dynamiques nom_classe *ob4; ob4 =new nom_classe (val1,val2) nom_classe *ob5; ob5 =new nom_classe (val) nom_classe *ob6; ob6 =new nom_classe () Constructeur Caractéristiques
  • 26. #include<iostream.h> class point { int x; int y; public: point(int,int); // un constructeur à deux paramètres void deplace(int,int); void affiche(); }; point::point(int abs,int ord) { x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"n"; } Constructeur Exemple void main() { point a(10,20),b(30,30); point c; // erreur a.affiche(); a.deplace (5,5); a.affiche(); b.affiche(); }
  • 27. Constructeur membres données dynamiques #include<iostream> using namespace std; class dvecteur { int dim; // dimension maximale float *V; public: dvecteur(int,float*); void decaler(float); void afficher(); }; dvecteur::dvecteur (int n,float *T) { dim=n; V= new float[dim]; for(int i=0;i<dim;i++) V[i]=T[i]; } void dvecteur::decaler(float d) { for(int i=0;i<dim;i++) V[i] += d; } void dvecteur::afficher() { for(int i=0;i<dim;i++) cout << V[i] <<" n" ; } int main() { float t1[]={1,1,1}, t2[]={2,2,2,2}; dvecteur V1(3,t1),V2(4,t2); V2 = V1; V2.afficher(); V1.decaler(5); V2.afficher(); return 0; }
  • 28. Constructeur de recopie Rôle  Initialise l’objet lors de sa déclaration par un autre objet Mamouni Mustapha C67965 Mamouni Mustapha C67965 P_existant P_nouveau
  • 29.  Porte le nom de la classe  N’a pas de type de retour  A un seul paramètre : une référence à un objet  Est facultatif S’il n’est pas défini le compilateur génère un constructeur par défaut  Ne peut pas être surdéfini Constructeur de recopie Caractéristiques
  • 30.  Syntaxe nomclasse :: nomclasse (nomclasse&) { …}  Est appelé implicitement lors des situations suivantes:  Déclaration initialisation nomclasse nouveau_objet=objet_existant;  Passage par valeur d’un objet en paramètre f(nomclasse objet)  Retour d’un objet déjà existant par une fonction return objet_existant; Constructeur de recopie Caractéristiques
  • 31. #include<iostream.h> class point { int x; int y; public: point(int,int); // un constructeur à deux paramètres point(const point&); // un constructeur à deux paramètres void deplace(int,int); void affiche(); }; point::point(int abs,int ord) { x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"n"; } Constructeur Exemple point::point(const point &p) { x=p.x; y=p.y; } void f(point p) { p.affiche(); } point g() { point h(1,1); return h; } void main() { point a(10,20); point c=a; c.affiche(); c.deplace (5,5); cout << "ici la fonction f" << endl; f(c); cout << "ici la fonction g" << endl; c = g(); c.affiche(); return 0; }
  • 32. Constructeur de recopie membres données dynamiques  Risque d’incohérence  Les deux objets (initial et la copie) se partageront une même zone mémoire  La modification des données de l’un affectera l’autre
  • 33. Constructeur membres données dynamiques #include<iostream> using namespace std; class dvecteur { int dim; // dimension maximale float *V; public: dvecteur(int,float*); dvecteur(dvecteur&); void decaler(float); void afficher(); }; dvecteur::dvecteur (int n,float *T) { dim=n; V= new float[dim]; for(int i=0;i<dim;i++) V[i]=T[i]; } void dvecteur::decaler(float d) { for(int i=0;i<dim;i++) V[i] += d; } void dvecteur::afficher() { for(int i=0;i<dim;i++) cout << V[i] <<" n" ; } dvecteur::dvecteur (dvecteur& vect) { dim=vect.dim; V= new float[dim]; for(int i=0;i<dim;i++) V[i]=vect.V[i]; } int main() { float t1[]={1,1,1}; dvecteur V1(3,t1); dvecteur V2 = V1; dvecteur V3(V1); V2.afficher(); V1.decaler(5); V2.afficher(); return 0; }
  • 34. Destructeur Rôle  Libération des ressources de l’objet à la fin de son utilisation  Libération de la zone mémoire allouée par un constructeur
  • 35.  Porte le nom de la classe précédé par le caractère ~  N’a pas de paramètres  N’a pas de type de retour  Ne peut pas être surdéfini Destructeur Caractéristiques
  • 36. Destructeur Exemple #include<iostream> using namespace std; class dvecteur { int dim; // dimension maximale float *V; public: dvecteur(int,float*); dvecteur(dvecteur&); ~dvecteur(); void decaler(float); void afficher(); }; dvecteur::dvecteur (int n,float *T) { dim=n; V= new float[dim]; for(int i=0;i<dim;i++) V[i]=T[i]; } void dvecteur::decaler(float d) { for(int i=0;i<dim;i++) V[i] += d; } void dvecteur::afficher() { for(int i=0;i<dim;i++) cout << V[i] <<" n" ; } dvecteur::dvecteur (dvecteur& vect) { dim=vect.dim; V= new float[dim]; for(int i=0;i<dim;i++) V[i]=vect.V[i]; } dvecteur::~dvecteur () { dim=0; delete V; cout<<"n Appel du destructeurn"; } void scenario(float d) { float t1[]={1,1,1}; dvecteur V1(3,t1); V1.afficher(); V1.decaler(d); V1.afficher(); } int main() { int d; for(d=1;d<4;d++) scenario(d); return 0; }
  • 37. Classe d’allocation static  Stockage dans la zone statique  Durée de vie permanente, égale à celle du programme  Même portée que les variables automatique  Initialisation au moment de la compilation, initialisation par défaut à 0  Syntaxe static float x;
  • 38. #include <stdio.h> void fonct() { static int x=0; int y=0; printf("x = %d, y = %dn",x++, y++); } int main() { int i ; for (i=0;i <10; i++) { printf(" iteration = %d ", i); fonct(); } return 0; } Classe d’allocation static Exemple
  • 39.  Applicable aux méthodes et aux attributs  Propriété indépendante de tous les objets (propriété de la classe) Classe d’allocation static
  • 40. Membres données static  Lors de la déclaration des objets chaque objet possède ses propres membres données  Exemple Ob1 Ob2 10 15 30 20
  • 41. Membres données static  Un membre static est partagé par tous les objets de la classe  Syntaxe Le membre est précédé par le mot clé static lors de la déclaration de la classe static type nom_var;  L’initialisation n’est pas automatique Type class_name::ident = 0; Ob1 Ob2 10 15 30 20 Ob3
  • 42. Membres données Static Exemple #include<iostream.h> class point { static int nb; int x; int y; public: point(int,int); void deplace(int,int); void affiche(); }; int point::nb=0; point::point(int abs,int ord) { nb++; x=abs; y=ord; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"nombre d'objets" << nb <<"n"; } void main() { point a(10,20); a.affiche(); a.deplace (5,5); a.affiche(); point b(30,30); b.affiche(); }
  • 43. Fonctions membres static  Sont indépendantes de tous les objets de la classe  Agissent sur des membres static  Sont appelées sans référence à un objet référencées directement par le nom de la classe nom_classe::fonct_static(…);
  • 44. Fonctions membres static  Peuvent être appelées avant la création de tout objet  Syntaxe class nom_classe { …. public: … static type fonct_static(….); };
  • 45. #include<iostream.h> class point { static int nb; int x; int y; public: point(int,int); void deplace(int,int); void affiche(); static void compteur(); }; int point::nb=0; point::point(int abs,int ord) { nb++; x=abs; y=ord; } void point::compteur() { cout <<"n nombre de points :"<<nb; } void point::deplace(int dx,int dy) { x+=dx; y+=dy; } void point::affiche() { cout << "position :" <<x <<"," <<y <<"nombre d'objets" << nb <<"n"; } void senario(int i) { point a(i,i); a.affiche(); } void main() { point a(i,i); a.affiche(); point::compteur(); for(int i=0;i<4;i++) senario(i); return 0; } Fonctions membres static Exemple
  • 46. Surdéfinition des fonctions membres  La surdéfinition peut être appliquée aux fonctions membres d’une classe  Plusieurs fonctions membres portent le même nom mais diffèrent dans le contenu selon le type et/ou le nombre de paramètres  Sémantiquement ces fonctions font la même action (ex afficher)  Le compilateur choisit la fonction à invoquer selon les paramètres effectifs  Plus de lisibilité : pas besoin de chercher plusieurs identificateurs pour la même action
  • 47. #include<iostream.h> class point { int x; int y; public: void initialise(int,int); void initialise(int); void initialise (); void deplace(int,int); void affiche(); }; void point::initialise(int abs,int ord) { x=abs; y=ord; } void point::initialise(int c) { x=c; y=c; } void point::initialise() { x=100; y=100; } Surdéfinition des fonctions membres
  • 48. Paramètres par défaut des fonctions membres  Une fonction membre peut attribuer des valeurs par défaut à certains paramètres omis lors de l’appel  Seuls les derniers paramètres peuvent avoir des valeurs par défaut  ≠ surdéfinition des fonctions Une seule fonction  !!! Attention risque d’ambiguïté avec la surdéfinition
  • 49. class point { int x; int y; public: void initialise(int =10,int =10); void deplace(int,int); void affiche(); }; void point::initialise(int abs,int ord) { x=abs; y=ord; } Paramètres par défaut des fonctions membres Exemple
  • 50. Fonctions amies  Une fonction amie est une fonction non membre d’une classe et possédant le droit d’accès aux membres privés de ses objets.  Intérêt : résoudre certains problèmes de communication entre objets  Fonction qui a besoin, dans certains cas, d’accéder aux membres privés de deux classes différentes  Attention !! : Violation du concept d’encapsulation  L’amitié est déclarée par le mot clé friend
  • 51. Fonctions amies  Fonction indépendante et amie d’une classe  Syntaxe class A { … public: … friend type_retour fonct_amie(…); … }; // définition de la fonction amie type_retour fonct_amie(…) { … }
  • 52. Fonctions amies  Remarque // Attention !!!! Fausse définition type_retour A::fonct_amie(…) { … }
  • 53. Fonctions amies  Fonction membre d’une classe A et amie d’une ou plusieurs classes  Syntaxe class A { … public: … type_retour fonct_amie(…); … }; class B { … public: … friend type_retour A::fonct_amie(…); };
  • 54. Fonctions amies  Toutes les fonctions membres d’une classe A sont amies d’une autre classe B  Syntaxe class A { … public: … }; class B { … public: … friend class A; // les fonctions membres sont amies de classe B };
  • 55. Fonctions amies  Exemple1 class point { int x; int y; public: point(int,int); void deplace(int,int); friend int complexe::coincide(point&); void affiche(); }; class complexe { int x; int y; public: complexe(int,int); int coincide(point&); void affiche(); … };
  • 56. class point { int x; int y; public: point(int,int); void deplace(int,int); friend int coincide(complexe&, point&); void affiche(); }; class complexe { int x; int y; public: complexe(int,int); int coincide(point&); friend int coincide(complexe&,point&); void affiche(); … }; Fonctions amies  Exemple2