Informatique Industrielle TD/TP1

Programmation Orientée Objet

Notion de Classes

Exercice 1 : Reprendre, programmer et tester les exemples vus en cours.

1. Classes Personnage et Arme :
class Personnage
{
private:
int m_vie;
int m_mana;
Arme m_arme;

public:
Personnage();
Personnage(std::string nomArme, int degatsArme);
~Personnage();
void recevoirDegats(int nbDegats);
void attaquer(Personnage &cible);
void boirePotionDeVie(int quantitePotion);
void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
bool estVivant();
void afficherEtat();
};

class Arme
{

private:
std::string m_nom;
int m_degats;

public:
Arme();
Arme(std::string nom, int degats);
void changer(std::string nom, int degats);
void afficher();
int getDegats() const;
};

2. Classes Duree :

class Duree
{
private:
int m_heures;
int m_minutes;
int m_secondes;

public:
Duree(int heures = 0, int minutes = 0, int secondes = 0);
Duree& operator+=(Duree const& duree);
void afficher(std::ostream &out) const;
bool estEgal(Duree const& b) const;
bool estPlusPetitQue(Duree const& b) const;
};
Ajouter les fonctions pour la surcharge des opérateurs :

Duree operator+(Duree const& a, Duree const& b);

std::ostream& operator<<(std::ostream& out, Duree const& duree);
bool operator==(Duree const& a, Duree const& b);
bool operator!=(Duree const& a, Duree const& b);
bool operator<(Duree const& a, Duree const& b);

Exercice 2 : Classes ZFraction

Le C++ permet d'utiliser des nombres entiers via le type int, des nombres réels via le type
double, mais il ne propose rien pour les nombre rationnels (1/5, 1/3, …). Ecrire une classe
représentant la notion de fraction que nous appelons ZFraction.

class ZFraction
{
private:
int m_numerateur;
int m_denominateur;

// Simplifie une fraction

void simplifie();

public:
ZFraction(int num, int den);
ZFraction(int nombre);
ZFraction();
void affiche(std::ostream& flux) const;
ZFraction& operator+=(ZFraction const& autre);
ZFraction& operator*=(ZFraction const& autre);
bool estEgal(ZFraction const& autre) const;
bool estPlusPetitQue(ZFraction const& autre) const;
};

Ajouter les fonctions pour la surcharge des opérateurs :

std::ostream& operator<<(std::ostream& flux, ZFraction const& fraction);

ZFraction operator+(ZFraction const& a, ZFraction const& b);

ZFraction operator*(ZFraction const& a, ZFraction const& b);

bool operator==(ZFraction const& a, ZFraction const& b);

bool operator!=(ZFraction const& a, ZFraction const& b);
bool operator<(ZFraction const& a, ZFraction const& b);
bool operator>(ZFraction const& a, ZFraction const& b);
bool operator>=(ZFraction const& a, ZFraction const& b);
bool operator<=(ZFraction const& a, ZFraction const& b);

//Calcul du pgcd
int pgcd(int a, int b);