UNIVERSITE DE LA MANOUBA Matière : POO

-----¤¤¤¤----- Classe : I.I. 1A

ECOLE NATIONALE DES SCIENCES DE A-U : 2016-2017
L'INFORMATIQUE
Série N°4 – Polymorphisme en C++
Exercice n°1
Soit le code C++ comportant les classes A et B suivantes :
class A class B : public A
{ {
public: public:
A(){cout<<"A::A()"<<endl;} B(){cout<<"B::B()"<<endl;}
virtual ~A() { cout<< "A:: ~A()"<<endl;} ~B(){cout<< "B:: ~B()"<<endl;}
virtual void f1() {cout << "A::F1()" << endl;} void f1() {cout << " B::f1()" << endl;}
void f2(){cout << " A::f2()" << endl;} virtual void f2() {cout << " B::f2()" << endl;}
}; } ;
1. Quel est le résultat d’affichage du code suivant ?
void main(){ B obj; }
Solution:
A::A()
B::B()
B:: ~B()
A:: ~A()
2. Quelle est la différence entre une méthode virtuelle et une méthode non virtuelle au niveau de la
convention d'appel ?
3. Quel est le résultat d’affichage du code suivant ?
void main()
{B *pB = new B;
A *pA = pB;
pA->f1();
pB->f2();
pB->f1();
pA->f2();}
Solution :
A::A()
B::B()
B::f1()
B::f2()
B::f1()
A::f2()
Exercice n°2
Soit le code c++ suivant :
class Figure{
public :
Figure(string nom) : nom_(nom) { }
string getNom() const { return nom_; }
virtual void intersection(const Figure& f) const = 0;
virtual void intersection(const Cercle& c) const = 0;
virtual void intersection(const Rectangle& r) const = 0;
private:
string nom_;};
class Cercle : public Figure{
public :
Cercle(string nom) : Figure(nom) { }
virtual void intersection(const Figure& f) const;
virtual void intersection(const Cercle& c) const;
virtual void intersection(const Rectangle& r) const;};
void Cercle::intersection(const Cercle& c) const
{cout << "Inter. cercle " << getNom() << " et cercle " <<c.getNom() <<endl;}
void Cercle::intersection(const Rectangle& r) const
{cout << "Inter. cercle " << getNom() << " et rectangle " <<r.getNom()<< endl;}
void Cercle::intersection(const Figure& f) const{f.intersection(*this);}
class Rectangle : public Figure{
public :
Rectangle(string nom) : Figure(nom) { }
virtual void intersection(const Figure& f) const;

1/10
virtual void intersection(const Cercle& c) const;
virtual void intersection(const Rectangle& r) const;
};
void Rectangle::intersection(const Cercle& c) const{cout << "Inter. rectangle " << getNom() << "
et cercle " <<c.getNom()<< endl;}
void Rectangle::intersection(const Rectangle& r) const {cout << "Inter. rectangle " << getNom()
<< " et rectangle " <<r.getNom() << endl;}
void Rectangle::intersection(const Figure& f) const {f.intersection(*this);}
1. Donnez l’arborescence des classes définies précédemment.
2. On vous demande de donner l’affichage obtenu lors de l’exécution du programme suivant :
void main(){
Cercle c1("C1");
Cercle c2("C2");
Rectangle r1("R1");
Rectangle r2("R2");
Figure* ptr1 = new Cercle("C3");
Figure* ptr2 = new Rectangle("R3");
cout << "Ligne 1" << endl;
c1.intersection(c2);
cout << "Ligne 2" << endl;
ptr1->intersection(r1);
cout << "Ligne 3" << endl;
c2.intersection(*ptr2);
cout << "Ligne 4" << endl;
ptr2->intersection(*ptr1);
delete ptr1;
delete ptr2;}
Solution :
Ligne 1
Inter. cercle C1 et cercle C2
Ligne 2
Inter. cercle C3 et rectangle R1
Ligne 3
Inter. rectangle R3 et cercle C2
Ligne 4
Inter. cercle C3 et rectangle R3
Exercice 3
Soit le code C++ suivant
class Process{ void Fonction(Thread x) { x.imprimer();}
int pid; Process obj_pro1;
public: int main( )
Process( ) { pid = 0; cout<<"Process Defaut"<<endl; } {Thread obj_thr1(2);
Process(Process& B) { pid=B.pid ; cout<<"Process Process *ptr_pro = new Process [2];
Copie\n"; ptr_pro[0].imprimer();
Process(int x) { pid = x; cout<<"Process delete [] ptr_pro;
Param"<<endl; } obj_thr1.imprimer();
~Process() { cout<<"Process Destructeur"<<endl; } ptr_pro = &obj_thr1;
virtual void imprimer() {cout << "pid="<< pid << ptr_pro->imprimer();
endl;} obj_thr1.Process::imprimer();
}; Process obj_pro2(obj_pro1);
class Thread : public Process{ obj_pro2.imprimer();
int tid; Fonction(obj_thr1);
Process p;
public: return 0;}
Thread():Process() { tid=0; cout<<"Thread Defaut\n";
}
Thread( int v):Process(v) { tid=1; cout<<"Thread
Param\n"; }
~Thread() {cout<<"Thread Destructeur"<<endl;}
void imprimer() { cout << "tid=" << tid << endl; }
};

1. Pour chacune des instructions suivantes, indiquez ce qui sera affiché à l’écran.
Process obj_pro1; Process Defaut
Thread obj_thr1(2); Process Param
Process Defaut
Thread Param

2/10
 Process *ptr_pro = new Process Process Defaut
[2]; Process Defaut
ptr_pro[0].imprimer(); pid=0
delete [] ptr_pro; Process Destructeur
Process Destructeur
obj_thr1.imprimer(); tid=1
ptr_pro = &obj_thr1; Pas d’affichage
ptr_pro->imprimer(); tid=1
obj_thr1.Process::imprimer(); pid=2
Process obj_pro2(obj_pro1); Process Copie
obj_pro2.imprimer(); pid=0
Fonction(obj_thr1); Process Copie
Process Copie
tid=1
Thread Destructeur
Process Destructeur
Process Destructeur
Fin du bloc Process Destructeur
Thread Destructeur
Process Destructeur
Process Destructeur
Process Destructeur

2. Ajouter le constructeur de recopie de la classe Thread qui doit contenir l’instruction

« cout<<"Thread Copie \n » et donner le nouveau affichage de l’instruction suivante :
Fonction(obj_thr1) ;
Process Defaut
Process Defaut
Thread Copie
tid=1
Thread Destructeur
Process Destructeur
Process Destructeur
Exercice 4
Une entreprise de Patagonie développe un moteur à huile de rutabaga, et dote plusieurs véhicules de ce moteur.
Avant d'effectuer des tests grandeur nature, l'entreprise conçoit un programme de simulation du comportement
des véhicules. Ce programme sera écrit en C++. On ne s'intéresse dans cet exercice qu'à une toute petite partie
de ce programme. Le problème que l'on veut résoudre dans un premier temps est celui de la représentation des
véhicules et du calcul de la vitesse maximum pouvant être atteinte par un véhicule. Tout ‘véhicule’ possède
une immatriculation (chaîne de caractères) et un poids à vide (réel). Certains véhicules peuvent transporter
un chargement : on appelle alors charge le poids de ce chargement. La charge d'un véhicule ne doit pas
dépasser un certain poids, que l'on appellera charge maximale, dépendant du type de véhicule. Les différents
types de véhicules dotés du fameux moteur sont les suivants : les petits bus, les camions citernes, et les
camions bâchés.
• la classe ‘petit_ bus’ a un poids à vide de 4 tonnes, et peut atteindre une vitesse maximale de 150 km/h. Il ne
possède pas de chargement (le poids des passagers est considéré comme négligeable par rapport au poids à
vide).
• la classe ‘camion_citerne’ a un poids à vide de 3 tonnes et une charge maximale de 10 tonnes. Sa vitesse
maximale dépend de sa charge :
- 130 km/h si la charge est nulle
- 110 km/h si la charge est inférieure ou égale à 1 tonne
- 90 km/h si la charge est supérieure à 1 tonne et inférieure ou égale à 4 tonnes

3/10
- 80 km/h pour une charge supérieure à 4 tonnes.
• la classe ‘camion_bâché’ a un poids à vide de 4 tonnes et une charge maximum de 20 tonnes. Sa vitesse
maximale dépend également de sa charge (mais à charge égale, un camion citerne a une vitesse maximale plus
faible, car le liquide qu'il transporte est plus instable qu'un chargement solide):
- 130 km/h si la charge est nulle
- 110 km/h si la charge est inférieure ou égale à 3 tonnes
- 90 km/h si la charge est supérieure à 3 tonnes et inférieure ou égale à 7 tonnes
- 80 km/h au delà.
Les classes ‘véhicule’, ‘petit_ bus’, ‘camion_citerne’, ‘camion_bâché’ possèdent une méthode affichage
‘affichage’ permettant d’afficher les caractéristiques de chaque véhicule. Les ingénieurs de l'entreprise
fournissent une formule permettant de calculer la consommation de carburant d'un véhicule en fonction de sa
vitesse et de son poids total (poids à vide + charge éventuelle) consommation = (vitesse-en-km/h)/10 +
(poids_total-en-tonnes). Cette formule est la même pour tous les types de véhicules, la méthode au calcul de
consommation de carburant correspondante est : float consommation (int v, int p), qui retourne la consommation
(en litres pour 100 km) d'un véhicule de poids p allant à une vitesse v.
Question 1
Donnez l’interface et l’implémentation des classes ‘Véhicule’, ‘petit_bus’, ‘camion_citerne’, ‘camion_bâché’.
class Vehicule {
protected :
string immatriculation ;
float poids_a_vide ;
int vitesse_max;
public :
Vehicule() {}
Vehicule(string c) {immatriculation=c;}
virtual ~Vehicule(){}
float consommation (int v, int p) const{return ((v)/10 + (p)) ;}
virtual void affichage () const { cout<<" immatriculation"<<immatriculation<<endl ;}
virtual int calcul_vitesse_maximale ()=0 ;
};
class Petit_bus : public Vehicule {
public:
Petit_bus(){poids_a_vide=4;
vitesse_max=150;}
~Petit_bus (){}
void affichage () const { Vehicule :: affichage() ;
cout<< " poids à vide"<<poids_a_vide<< " vitesse_max "<<vitesse_max<<endl;}
int calcul_vitesse_maximale (){ return vitesse_max ;}
};
class Camion_citerne : public Vehicule{
int charge ;
int charge_max ;
public:
Camion_citerne (){poids_a_vide=3;
charge_max =10;}
void set_charge(int c){if(c<charge_max)charge=c ;}
int get_charge() const {return charge ;}
void affichage () const{ Vehicule :: affichage() ;
cout<< "poids à vide "<<poids_a_vide<< "charge "<<charge<< "charge_max "<<charge_max<<endl;}
int calcul_vitesse_maximale (){ if (charge==0) vitesse_max= 130 ;
else if (charge <=1) vitesse_max=110 ;
else if (charge <=4) vitesse_max= 90 ;
else if (charge >4) vitesse_max=80 ;
return vitesse_max ;}
};

4/10
class Camion_bache : public Vehicule{
int charge ;
int charge_max ;
public:
Camion_bache(){poids_a_vide=4;
charge_max =20;}
void set_charge(int c){if(c<charge_max)charge=c ;}
int get_charge() const {return charge ;}
void affichage () const{ Vehicule :: affichage() ;
cout<< "poids à vide "<<poids_a_vide<< "charge "<<charge<< "charge_max"<<charge_max<<endl;}
int calcul_vitesse_maximale (){ if (charge==0) vitesse_max= 130 ;
else if (charge <=3) vitesse_max=110 ;
else if (charge <=7) vitesse_max= 90 ;
else vitesse_max=80 ;
return vitesse_max ;}
};
Question 2
On s'intéresse maintenant à la définition d'une classe Convoi, permettant de gérer un convoi de véhicules.
Cette classe contient une collection de véhicules hétérogènes. L’ajout des véhicules se fait toujours à la fin. La
classe Convoi doit savoir calculer la vitesse maximale d'un convoi, sachant que cette vitesse correspond à la
plus petite des vitesses maximales des véhicules du convoi. Cette classe possède aussi les méthodes permettant
l’ajout et la suppression de véhicules.
Donnez l’interface et l’implémentation de la classe ‘Convoi’ (pensez à utiliser le conteneur Vector de STL).
class Convoi{
vector <Vehicule *>v ;
public :
Convoi(){}
~ Convoi(){vector <Vehicule *>::iterator itr;
for (itr = v.begin(); itr !=v.end(); ++itr)
delete *itr;}
void ajouter(Vehicule* v1){v.push_back(v1) ;}
void supprimer (Vehicule * v1){
vector <Vehicule *>::iterator pos;
pos=find (v.begin(), v.end(), v1);
if (pos !=v.end())
v.erase(pos);
else cout<<"vehicule inexistant"<<endl; }
int calcul_vitesse_max(){
vector <Vehicule *>::iterator itr;
vector <Vehicule *>::iterator b=v.begin();
int vi_max= (*b)-> calcul_vitesse_maximale();
for (itr=v.begin() ; itr!=v.end(); ++itr) {
if ((*itr)-> calcul_vitesse_maximale()<vi_max) vi_max= (*itr)-> calcul_vitesse_maximale() ;
return vi_max ;}}
void afficher() {
vector <Vehicule *>::iterator itr ;
for (itr = v.begin(); itr != v.end(); ++itr){
(*itr)->affichage();}}
};
Question 3
Donnez la partie du code permettant de :
a) créer un convoi ‘C’,
b) créer deux camions bâchés
c) créer un petit bus
d) créer trois camions citerne

5/10
 e) ajouter ces véhicules à ‘C’
f) afficher les descriptions et la vitesse maximale de chaque véhicule de ‘C’.
int main ()
{Convoi C ;
Camion_bâche * Cb1, *Cb2 ;
Cb1=new Camion_bache ;
Cb2=new Camion_bache ;
Petit_bus * b =new Petit_bus ;
Camion_citerne *Cc1, *Cc2, *Cc3 ;
Cc1=new Camion_citerne ;
Cc2=new Camion_citerne ;
Cc3=new Camion_citerne ;
C. ajouter(Cb1) ;
C. ajouter(Cb2) ;
C. ajouter(b) ;
C. ajouter(Cc1) ;
C. ajouter(Cc2) ;
C. ajouter(Cc3) ;
C.afficher();
cout<<"La vitesse maximale de C est"<< C.calcul_vitesse_max() ;
return 0;}
Exercice 5
Le but de cet exercice est de regrouper dans une classe de base, appelée BaseListe, les opérations communes
aux listes LIFO et FIFO, puis de spécialiser cette classe par dérivation en une classe permettant de gérer une
pile (liste LIFO) et une classe permettant de gérer une queue (liste FIFO).
Ecrire une classe BaseListe, une classe ListeLifo, et une classe ListeFifo pouvant être utilisées avec le
programme suivant :
void main()
{
BaseListe *ptPile;
ListeFifo fifo;
ListeLifo lifo;
ptPile=&fifo;
*ptPile<0<1; //on empile 0 puis 1
cout<<"pile="<<*ptPile; //à l'écran : pile = 0 1
int i;
*ptPile>i; //on dépile dans i
cout<<"pile="<<*ptPile<<"i="<<i; //à l'écran pile=1 i=0
ptPile=&lifo;
*ptPile<0<1; //on empile 0 puis 1
cout<<"pile="<<*ptPile; //à l'écran : pile = 0 1
*ptPile>i; //on dépile dans i
cout<<"pile="<<*ptPile<<"i="<<i; //à l'écran pile=0 i=1
}
Solution:
class BaseListe
{
protected:
int * tab;
int ind;
int taille;
public:
BaseListe(int n=0):taille(n){ind=0; tab=new int[taille];
}
virtual ~BaseListe(void){}
BaseListe& operator< (int i){tab[ind]=i; ind++; taille++; return *this;}
virtual BaseListe& operator> (int& j)
{j=tab[taille-1]; ind--; taille--; return *this;}
friend ostream & operator<<(ostream & o, BaseListe p)

6/10
{for (int i=0; i<(p.taille); i++) {o<<p.tab[i]<<" ";}
cout<<endl;
return o;}
};
class ListeLifo : public BaseListe
{
public:
ListeLifo(void){}
~ListeLifo(void){}
};
class ListeFifo :public BaseListe
{
public:
ListeFifo(void){}
ListeFifo& operator> (int& j)
{j=tab[0];
for (int i=0; i<taille; i++) {tab[i]=tab[i+1];} taille--; return *this;}
~ListeFifo(void){}
};
Exercice 6
On se propose d'implémenter, en C++, une partie d'un logiciel de gestion du courrier postal. Il s'agit
d'implémenter l’ensemble des classes permettant cette gestion et d'ajouter toutes les méthodes nécessaires à leur
bon fonctionnement. Il est à noter que tout au long de cet exercice les attributs des classes à définir doivent
être non publics. Nous commençons par considérer les objets postaux. Ces objets sont de deux catégories :
lettres et colis. Tous les objets postaux ont les caractéristiques suivantes :
- une origine,
- une destination,
- un code postal,
- un poids (en grammes),
- un volume (en m3),
- un taux de recommandation (égal à 0, 1 ou 2).
On doit pouvoir calculer leur tarif d'affranchissement, leur tarif de remboursement, et afficher une chaîne qui
décrit l'objet.
Les lettres peuvent en outre avoir un certain caractère d'urgence.
Le tarif d'affranchissement d'une lettre se calcule de la manière suivante. Le tarif de base est de 0.5 UM (unité
monétaire) auquel s'ajoutent cumulativement :
- 0.5 UM si le taux de recommandation est 1, 1.5 UM si le taux de recommandation est 2,
- 0.30 UM si c'est une lettre urgente.
Le tarif de remboursement est de :
- 0 UM si le taux de recommandation est égal à 0,
- 1.5 UM si le taux est égal à 1,
- 15 UM si le taux est égal à 2.
La chaîne qui décrit une lettre a la forme suivante :
Lettre code postal/destination/taux de recommandation/caractère d'urgence
Par exemple : Lettre 7742/famille Kirik, igloo 5 banquise nord/1/ordinaire
Les colis possèdent les caractéristiques complémentaires suivantes :
- une déclaration de contenu (texte)
- une valeur déclarée (en UM)
Le tarif d'affranchissement d'un colis s'obtient par cumul des sommes suivantes :
- 2 UM dans tous les cas (tarif de base),
- 0.5 UM si le taux de recommandation, est 1, 1.5 UM si le taux de recommandation est 2 (comme pour les
lettres),
- 3 UM de surtaxe si le colis dépasse 1/8 de m3.
Le tarif de remboursement d'un colis est de :
- 10% de la valeur déclarée si le taux de recommandation est 1,

7/10
- 50% de la valeur déclarée si le taux de recommandation est 2,
- rien si le taux de recommandation est 0.
La chaîne qui décrit un colis a la forme suivante :
Colis code postal/destination/taux de recommandation/volume/ valeur déclarée
Par exemple : Colis 7854/famille Kaya, igloo 10, terres ouest/2/0.02/200
Question 1
Donnez l’interface et l’implémentation des classes ‘Objet_postal’, ‘Lettre’ et ‘Colis’.
class ObjetPostal
{protected:
string origine;
string destination;
int code_postal;
float poids;
float volume;
int taux_recommandation;
public:
ObjetPostal(string o="inconnue", string d="inconnue", int c=0, int p=0, float v=0, int t=0){origine=o;
destination=d; code_postal=c; poids=p; volume=v; taux_recommandation=t;}
virtual ~ObjetPostal(){}
float getVolume()const {return volume;}
void setVolume(float v) {volume=v;}
virtual void affiche()const ;
{cout<<code_postal<<"/"<<destination<<"/"<<taux_recommandation<<"/";}
virtual float calcul_tarif_Affranchissement()=0;
virtual float calcul_tarif_remboursement()=0;
};
class Lettre : public ObjetPostal {
private:
bool urgente;
public:
Lettre(bool u=false){urgente=u;}
~Lettre(){}
void affiche()const{cout<<"Lettre"; ObjetPostal::affiche(); cout <<"/";
if (urgente) cout<<"urgente"<<endl; else cout<<"ordinaire"<<endl;}
float calcul_tarif_Affranchissement(){ float res=0.5;
if(taux_recommandation==1)
res+=1;
else if (taux_recommandation==2)
res+=1.5;
if(urgente)
res+=0.30;
return res;}
float calcul_tarif_remboursement(){ float res;
if(taux_recommandation==0)
res=0;
else if (taux_recommandation==1)
res=1.5;
else if (taux_recommandation==2)
res=15;
return res;}
};
class Colis : public ObjetPostal{
private:
string declareContenu;
float valeur_déclarée;

8/10
 public:
Colis(string dc="mystere", float vd=0){declareContenu=dc; valeur_déclarée=vd;}
~Colis(){}
void affiche()const{cout<<"Colis";ObjetPostal::affiche(); cout<<volume<<"/"<<valeur_déclarée<<endl;}
float calcul_tarif_Affranchissement(){ float res=2;
if(taux_recommandation==1)
res+=0.5;
else if (taux_recommandation==2)
res+=1.5;
if(volume>(1/8)) {res+=3;}
return res;}
float calcul_tarif_remboursement(){ float res;
if(taux_recommandation==0)
res=0;
else if (taux_recommandation==1)
res=0.1*valeur_déclarée;
else if (taux_recommandation==2)
res=0.5*valeur_déclarée;
return res;}
};
Question 2
On s'intéresse maintenant à la définition d'une classe ‘Sac_postal’ permettant la description des sacs
postaux. Un sac postal peut contenir un certain nombre d’objets postaux et dispose d'une capacité
maximale. Cette capacité est de 0,5 m3 pour un sac ordinaire. On peut fabriquer des sacs d'une autre
capacité, sur demande précisant la capacité voulue.
On doit pouvoir ajouter un objet dans un sac, s'il y rentre. On veut aussi connaître le volume occupé par un
sac, et afficher son contenu. Cette classe possède aussi les méthodes permettant la suppression et la
recherche d’un objet postal.
Pour l’implémentation de la classe ‘Sac_postal’, on a besoin d’un conteneur permettant de stocker les
objets postaux. A cet effet, on se propose initialement de définir et d’implémenter en c++, une classe
représentant des tableaux dynamiques qu’on nomme ‘Vecteur’. Cette classe ‘Vecteur’ peut gérer
n’importe quel type d’éléments. Pour simplifier, on définira seulement les opérations sur les tableaux qui
sont utiles pour le sac d’objet, c’est-à-dire ajouter un élément, supprimer un élément, savoir si un élément
est présent ou non, savoir si le tableau est vide ou non et connaître la taille du tableau.
1. Donnez l’interface et l’implémentation de la classe ‘Vecteur’.
template <class T>
class Vecteur {
T* tab;
int taille;
int indice;
public:
Vecteur (int taille=0) : taille (taille), indice (-1){ tab = new T[taille];}
~ Vecteur (){ delete [] tab; }
void ajouter(T e){ if ( ! exist(e) ) tab[++indice] = e; }
void supprimer(T e){
int ind=0;
while ( (ind <= indice) && (tab[ind] != e) ) ind++;
if ( ind <= indice) {
indice--;
for (int i=ind; i< indice; i++) tab[i] = tab[i+1];
}
}
bool exist(T e) const{
for (int i=0; i< size(); i++)

9/10
 if (tab[i]==e) return true;
return false;}
bool vide() const{ return (indice==-1); }
int size() const{ return (indice+1); }
};
2. Donnez l’interface et l’implémentation de la classe ‘Sac_postal’(pensez à utiliser la classe
‘Vecteur’).
class SacPostal{
private:
vecteur <ObjetPostal*> contenu;
float capacite_maximale;
public:
SacPostal(float cap=0.5){capacite_maximale=cap;}
~SacPostal(){}
void ajouter(ObjetPostal* po)
{if (po->getVolume()< capacite_maximale) {contenu.ajouter(po);
capacite_maximale-=po->getVolume();}}
float volume() const {float v=0; for (int i=0; i<contenu.size(); i++)
v+=contenu[i]->getVolume(); return v;}
void afficher()const
{for (int i=0; i<contenu.size(); i++)
contenu[i]->affiche();
}
void supprimer(ObjetPostal* po) {contenu.supprimer (po) ;}
bool rechercher(ObjetPostal* po) {return (contenu.exist(po)) ;}
};
Question 3
Donnez la partie du code permettant de :
g) créer un sac postal ‘psac’,
h) créer deux lettres ‘pl1’ et ‘pl2’.
i) créer deux colis ‘pc1’ et ‘pc2’.
j) ajouter ces objets postaux à ‘psac’.
k) afficher le contenu de ‘psac’.
int main (){
SacPostal *pSac = new SacPostal();
Lettre *pl1 = new Lettre;
Lettre *pl2 = new Lettre;
Colis *pc1 = new Colis;
Colis *pc2 = new Colis;
pSac->ajouter (pc1); pSac->ajouter (pc2);
pSac->ajouter (pl1); pSac->ajouter (pl2);
pSac->afficher() ;
return 0;
}

10/10