PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 5 - Le polymorphisme

Exercice 5.1 - Les véhicules

Voici la représentation UML de quatre classes CVehicule,  CAvion , CAutomobile et CDecapotable:

vehicules uml
Voici le code C++ correspondant :

class CVehicule  
{
	float VitesseMax_ ;
public:
	CVehicule();   
	CVehicule(float VitesseMax);
	~CVehicule();
	float Deplacer(float Distance);
};

class CAvion : public CVehicule
{
	float AltitudeMax_;
public:
	CAvion();
	CAvion(float VitesseMax, float AltitudeMax);
	~CAvion();
	float Deplacer(float Distance);
	void Decoller();
};

class CAutomobile : public CVehicule
{

	int NbRoues_;
public:
	CAutomobile();
	CAutomobile(float VitesseMax, int NbRoues);
	float Deplacer(float Distance);
	void ChangerRoue();
	~CAutomobile();
};

class CDecapotable : public CAutomobile  
{
	float GrandeurToit_;
public:
	CDecapotable() ;
	CDecapotable(float VitesseMax, int NbRoues, 
                 float GrandeurToit) ;
	~CDecapotable();
	float Deplacer(float Distance);
	void OuvrirToit();
};

et le programme principal suivant:

int main()
{
    CDecapotable* pObj1 = new CDecapotable;
    CDecapotable* pObj2 = new CAutomobile;
    CDecapotable* pObj3 = new CAvion; 
    CDecapotable* pObj4 = new CVehicule; 
    
    CAutomobile* pObj5 = new CDecapotable;
    CAutomobile* pObj6 = new CAutomobile;
    CAutomobile* pObj7 = new CAvion;
    CAutomobile* pObj8 = new CVehicule; 
    
    CAvion* pObj9 = new CDecapotable;
    CAvion* pObj10 = new CAutomobile;
    CAvion* pObj11 = new CAvion;
    CAvion* pObj12 = new CVehicule; 
    
    CVehicule* pObj13 = new CDecapotable;
    CVehicule* pObj14 = new CAutomobile;
    CVehicule* pObj15 = new CAvion;
    CVehicule* pObj16 = new CVehicule; 
    
    pObj1->Deplacer(1.0f);
    pObj2->Deplacer(1.0f);    
    pObj3->Deplacer(1.0f);    
    pObj4->Deplacer(1.0f);    
    
    pObj5->Deplacer(1.0f);    
    pObj6->Deplacer(1.0f);    
    pObj7->Deplacer(1.0f);    
    pObj8->Deplacer(1.0f);    
    
    pObj9->Deplacer(1.0f);    
    pObj10->Deplacer(1.0f);    
    pObj11->Deplacer(1.0f);    
    pObj12->Deplacer(1.0f);    
    
    pObj13->Deplacer(1.0f);    
    pObj14->Deplacer(1.0f);    
    pObj15->Deplacer(1.0f);    
    pObj16->Deplacer(1.0f);    
}
  1. Quelles sont les lignes du programme principal qui ne compilent pas? Expliquez pourquoi ces lignes ne compilent pas et mettez ces lignes en commentaire.
  2. Pour chacun des appels (qui ne sont pas commentés!) à la méthode Déplacer(), déterminez la version de la méthode qui est utilisée (CVehicule,  CAvion, CAutomobile ou CDecapotable).
  3. Ajoutez le mot-clé virtual devant toutes les déclarations des méthodes Deplacer(), puis déterminez de nouveau la version de la méthode qui est utilisée (CVehicule,  CAvion, CAutomobile ou CDecapotable).

Exercice 5.2 - Le retour des oiseaux migrateurs

Le printemps est là et un des signes annonciateurs de la belle saison est le retour des oiseaux migrateurs qui parcourent le vaste ciel. Comme c'est le cas chez plusieurs espèces, il y a des oiseaux meneurs meneur et des oiseaux suiveurs suiveu.

Une fois de plus, copiez votre exercice 3.7 dans un nouveau répertoire et renommez-le Exercice 5.2.

Ajoutez à votre projet la classe COiseau qui doit dériver de la classe CPersonnage et qui contient les membres suivants:

Ajoutez à votre projet la classe CMeneur qui doit dériver de la classe COiseau et qui contient les membres suivants:

Ajoutez à votre projet la classe CSuiveu qui doit dériver de la classe COiseau et qui contient les membres suivants:

De plus, vous devez obligatoirement utiliser le programme principal suivant tout en complétant la fonction TrouverPlusProcheMeneur:

// Exercice5.2.h
      #pragma once

const int Largeur = 576;
const int Hauteur = 576;
const int NbIterations = 10000;
const int NbMeneurs = 5;
const int NbSuiveux = 45;
const int NbOiseaux = NbMeneurs + NbSuiveux;

// main.cpp
#include <SFML/Graphics.hpp>
#include "Exercice5.2.h"
#include "Meneur.h"
#include "Suiveu.h"


///////////////////////////////////////////////////////////////////////////
// TrouverPlusProcheMeneur
// But: la fonction trouve le meneur le plus proche de l'oiseau passé en
//      paramètre. Pour ce faire, la fonction doit tester chacun des
//      oiseaux du tableau. Si l'oiseau est un meneur et que l'oiseau
//      n'est pas le même que l'oiseau courant alors la distance entre
//      les deux oiseaux est calculée. La distance entre deux points 
//      se calcule avec la formule suivante: sqrt( (x1-x2)^2 + (y1-y2)^2 ).
//      La distance minimale ainsi qu'un pointeur vers le meneur sont
//      conservés dans des variables temporaires. Le pointeur vers le meneur
//      le plus proche est retourné.
//      Il est à noter qu'il n'est pas utile de calculer la racine lorsque
//      l'on cherche le minimum. 
//      
// Intrants: OiseauCourant: oiseau dont on veut trouver 
//                          le plus proche meneur
//           tab:  tableau de tous les oiseaux
//           NbOiseaux: taille du tableau
// Extrant:  pointeur vers le meneur le plus proche
///////////////////////////////////////////////////////////////////////////

const COiseau* TrouverPlusProcheMeneur(const COiseau* OiseauCourant, COiseau* Tab[], int NbOiseaux)
{
 

   // Cette ligne permet seulement de compiler le programme principal, mais il vous faudra
   // la modifier lorsque que vous aurez terminé l'implémentation de cette fonction.
   return OiseauCourant; 
}

int main(int argc, char *argv[])
{
   COiseau* Tab[NbOiseaux];

   RenderWindow Fenetre(VideoMode(Largeur, Hauteur), "Le retour des oiseaux migrateurs");
   Texture FondImg;
   if (!FondImg.loadFromFile("ciel.bmp"))
   {
      return EXIT_FAILURE;
   }
   Sprite Fond(FondImg);

   Texture SuiveuImg;
   if (!SuiveuImg.loadFromFile("Suiveu.png"))
   {
      return EXIT_FAILURE;
   }

   Texture MeneurImg;
   if (!MeneurImg.loadFromFile("Meneur.png"))
   {
      return EXIT_FAILURE;
   }

   srand(static_cast<unsigned int>(time(0)));

   for (int i = 0; i < NbSuiveux; i++)
   {
      Tab[i] = new CSuiveu(SuiveuImg, rand() % (Largeur),
         rand() % (Hauteur));
   }
   for (int i = NbSuiveux; i < NbOiseaux; i++)
   {
      Tab[i] = new CMeneur(MeneurImg, rand() % (Largeur),
         rand() % (Hauteur));
   }

   for (int i = 0; i <NbIterations; i++)
   {
      Fenetre.clear();
      Fenetre.draw(Fond);
      for (int i = 0; i < NbOiseaux; i++)
      {
         const COiseau* PlusProche =
            TrouverPlusProcheMeneur(Tab[i], Tab, NbOiseaux);
         Tab[i]->SeDeplacer(PlusProche);
         Tab[i]->Afficher(Fenetre);
      }
      Fenetre.display();
      sleep(milliseconds(10));
   }
   for (int i = 0; i < NbOiseaux; i++)
   {
      delete Tab[i];
   }
   return 0;
}

Il est à noter que la programmation correcte de la méthode TrouverPlusProcheMeneur est un défi. Ne vous laissez pas impressionner par la tâche et demandez l'aide de votre gentil enseignant si vous éprouvez des difficultés. Mieux vaux remettre votre exercice avec la version initiale de cette fonction plutôt que de ne pas remettre votre exercice du tout.

Vos oiseaux peuvent se mouvoir dans le somptueux ciel suivant:

ciel