Vous êtes sur la page 1sur 25

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)

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

LANGAGE c++

S. EL GAROUANI ENSA Fès 2017-2018

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;
}

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

Présentation et Apport du langage C++

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

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

3
Présentation et Apport du langage C++

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);

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

Présentation et Apport du langage C++


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);
}

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

4
Présentation et Apport du langage C++

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

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

Présentation et Apport du langage C++


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;}
}

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

5
Présentation et Apport du langage C++

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.

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

Présentation et Apport du langage C++

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();

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

6
Présentation et Apport du langage C++

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
}

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

Présentation et Apport du langage C++


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;

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

7
Présentation et Apport du langage C++
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

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

Présentation et Apport du langage C++

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.

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

8
Présentation et Apport du langage C++
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.

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

Présentation et Apport du langage C++

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);}

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

9
CONCEPTS DE L’APPROCHE ORIENTÉE OBJET

S. EL GAROUANI ENSA Fès 2017-2018

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

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

10
Concepts de l’approche orientée objet

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.

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

Concepts de l’approche orientée objet


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

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

11
Concepts de l’approche orientée objet
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)

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

Concepts de l’approche orientée objet

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é

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

12
Concepts de l’approche orientée objet
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.

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

Concepts de l’approche orientée objet

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.

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

13
Concepts de l’approche orientée objet

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

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

Concepts de l’approche orientée objet

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

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

14
Concepts de l’approche orientée objet
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

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

Concepts de l’approche orientée objet


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()

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

15
Concepts de l’approche orientée objet
Exemples

Chaine.h

# include <iostream>
using namespace std;
class chaine {
// std::string s;
string s;
int i;
public :
chaine();
bool boolean();
void afficher();
};

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

Concepts de l’approche orientée objet


Exemples Chaine.cpp

# include <string.h>
#include "chaine.h"
using namespace std;
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(); }
S. EL GAROUANI ENSA Fès 2017-2018 32

16
CLASSES ET OBJETS

S. EL GAROUANI ENSA Fès 2017-2018

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.

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

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.

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

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

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

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( );
} ;

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

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) {……}

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

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.

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

Classes et Objets
Exemple :Implémentation de la classe Point
//fichierPoint.cpp
#include<math.h>
#include "Point.h«
using namespace std;

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 ; }

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

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();

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

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

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

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); }

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

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.

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

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;
} ;
}

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

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.

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

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 }

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

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

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

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); }
}

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

25