MultiHéritage et Classe Forme

VOici le sujet du partiel de C++ de l'année dernière... Si quelqu'un l'a déjà fait ca serait super sympas de m'en faire profiter car le mien est cette semaine et j'ai encore besoin d'entrainement! Je cherche particulierement la question 1) et 5)... Merci d'avance!

[quote]On définit une hiérarchie de formes géométriques comportant le cercle, le triangle, le rectangle et le carré. Pour chaque forme, on veut connaître son périmètre et sa surface. Il sera possible de déplacer une forme dans le plan, on définira pour cela une classe Vecteur.
1) Ecrire les classes, dont une classe abstraite Forme, nécessaires à l'implémentation de cette hiérarchie en vous basant sur l'extrait de programme ainsi que le résultat d'exécution fournis en annexes.
2) Remplir les zones marquées ************ dans ce programme.
3) Où intervient le polymorphisme dans ce programme ?
4) Expliquez l'ordre d'appel des constructeurs et destructeurs.
5) Ecrire les modifications permettant d'écrire les déplacements sous la forme :
Vecteur v(50,50); ou : Vecteur v(50,50);
cercle = cercle + v; cercle += v ;

Annexe 1 : Extrait du programme

void main()
{
Cercle cercle(10,10,4);
cout << endl << cercle << " surface=" << cercle.surface() << endl;

Triangle triangle(20,20,3);
cout << endl << triangle << " surface=" << triangle.surface() << endl;

Rectangle rectangle(30,30,2,5);
cout << endl << rectangle << "surface=" << rectangle.surface() << endl;

Carre *carre = new Carre(100,100,2);
cout << endl << *carre << " surface=" << carre->surface() << endl << endl;

cercle.deplace(50,50);
cout << "déplacement " << endl;
cout << cercle << endl << endl;

*************; // déclaration du tableau initialisé ci-dessous
tab[0] = &cercle;
tab[1] = ▵
tab[2] = &rectangle;
tab[3] = carre;

float surf=0.0;
for (int i=0; i<4; i++) surf += *****************;

cout << "surface totale : " << surf << endl << endl;

cout << "périmètre d'une forme tirée au hasard" << endl;
srand((unsigned int) time(NULL));
****** ptr = tab[rand() % 4]; // définition de ptr
cout << **** << " périmètre=" << **************** << endl << endl;

cout << "destruction de carré alloué dynamiquement" << endl;
ptr = carre;
delete ptr;
cout << endl;
}

Annexe 2 : Résultat d'exécution

- Forme::Forme -- Cercle::Cercle -
Cercle (10,10) r=4 surface=50.2655
- Forme::Forme -- Triangle::Triangle -
Triangle (20,20) c=3 surface=4.5
- Forme::Forme -- Rectangle::Rectangle -
Rectangle (30,30) L=2 l=5 surface=10
- Forme::Forme -- Rectangle::Rectangle -- Carre::Carre -
Carre (100,100) c=2 surface=4

déplacement
Cercle (60,60) r=4

surface totale : 68.7655

périmètre d'une forme tirée au hasard
Carre (100,100) c=2 périmètre=8

destruction de carre alloué dynamiquement
- Carre::~Carre -- Rectangle::~Rectangle -- Forme::~Forme -

- Rectangle::~Rectangle -- Forme::~Forme -
- Triangle::~Triangle -- Forme::~Forme -
- Cercle::~Cercle -- Forme::~Forme -
[/quote]

Hello
J'espère que ca pourra te servir.
C'est une solution ; il y en a sûrement des meilleures.

Désolé, c'est un peu tard...

/*----------------------------------------------------------*
* *
* form.h *
* *
* Définit les classes de formes. *
* *
*----------------------------------------------------------*/

#ifndef FORM__INCLUDED__
#define FORM__INCLUDED__

#include <iostream>

#define PI 3.1415926535f
#define SQR3_4 0.4330127018f

// Class de base.
class Forme
{
public:
// Coordonnées:
int x, y ;
// Constructeur / destructeur
Forme(int, int) ;
~Forme() ;

// Déplacement
void deplace(int, int) ;

} ;

// Class dérivées:
// Class cercle :
class Cercle : public Forme
{
public:
// Constructeur / destructeur
Cercle(int, int, int) ;
~Cercle() ;

// Surface / périmètre
float surface() ;
float perimetre() ;

// Membre propre
int rayon ;
} ;

// Class triangle :
class Triangle : public Forme
{
public:
// Constructeur / destructeur
Triangle(int, int, int) ;
~Triangle() ;

// Surface / périmètre
float surface() ;
float perimetre() ;

// Membre propre
int cote ;
} ;

// Class rectangle :
class Rectangle : public Forme
{
public:
// Constructeur / destructeur
Rectangle(int, int, int, int) ;
~Rectangle() ;

// Surface / périmètre
float surface() ;
float perimetre() ;

// Membres propres
int longueur,
largeur ;
} ;

// Class carré :
class Carre : public Rectangle
{
public:
// Constructeur / destructeur
Carre(int, int, int) ;
~Carre() ;
} ;

// Surcharge de << pour l'affichage
inline std::ostream& operator<<(std::ostream& os, const Carre& c)
{
os << "Carre (" << c.x << ", " << c.y << ") "
<< "c=" << c.largeur ;
return os;
}

inline std::ostream& operator<<(std::ostream& os, const Cercle& c)
{
os << "Cercle (" << c.x << ", " << c.y << ") "
<< "r=" << c.rayon ;
return os;
}

inline std::ostream& operator<<(std::ostream& os, const Rectangle& r)
{
os << "Rectangle (" << r.x << ", " << r.y << ") "
<< "L=" << r.longueur << " l=" << r.largeur ;
return os;
}

inline std::ostream& operator<<(std::ostream& os, const Triangle& t)
{
os << "Triangle (" << t.x << ", " << t.y << ") "
<< "c=" << t.cote ;
return os;
}



#endif // FORM__INCLUDED__

/*----------------------------------------------------------*
* *
* form.cpp *
* *
* Fonctions membres des classes Forme et dérivées *
* *
*----------------------------------------------------------*/

#include "form.h"

// Class de base:
Forme::Forme(int a, int b)
{
std::cout << "- Forme::Forme -" ;
x = a ;
y = b ;
}

Forme::~Forme()
{
std::cout << "- Forme::~Forme -" << std::endl ;
}

void Forme::deplace(int dx, int dy)
{
x += dx ;
y += dy ;
}

// Class dérivées:
// Cercle
Cercle::Cercle(int a, int b, int c) : Forme(a, b)
{
std::cout << "- Cercle::Cercle -" ;
x = a ;
y = b ;
rayon = c ;
}

Cercle::~Cercle()
{
std::cout << "- Cercle::~Cercle -" ;
}


float Cercle::perimetre()
{
return (2 * PI * rayon) ;
}

float Cercle::surface()
{
return (PI * rayon * rayon) ;
}

// Rectangle
Rectangle::Rectangle(int a, int b, int L, int l) : Forme(a, b)
{
std::cout << "- Rectangle::Rectangle -" ;
largeur = l ;
longueur= L ;
}

Rectangle::~Rectangle()
{
std::cout << "- Rectangle::~Rectangle -" ;
}

float Rectangle::perimetre()
{
return (2 * longueur * largeur) ;
}

float Rectangle::surface()
{
return (longueur * largeur) ;
}

// Triangle
Triangle::Triangle(int a, int b, int c) : Forme(a, b)
{
std::cout << "- Triangle::Triangle -" ;
cote = c ;
}

Triangle::~Triangle()
{
std::cout << "- Triangle::~Triangle -" ;
}

float Triangle::perimetre()
{
return (3 * cote) ;
}

float Triangle::surface()
{
return (cote * cote * SQR3_4) ;
}

// Carré
Carre::Carre(int a, int b, int c) : Rectangle(a, b, c, c)
{
std::cout << "- Carre::Carre -" ;
}