PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 1 - Classes et objets

Exercice 1.1

Exécutez le pas à pas suivant et conservez précieusement les projets Labo1 et Labo1(b) dans vos documents. Notez les réponses aux questions en insérant des commentaires dans le code source de votre programme.

Exercice 1.1 - Pas a pas

Exercice 1.2

Programmez la classe CCompte qui possède la déclaration suivante:

 

class CCompte
{
private:
   float Solde_;
public:
   // Initialise le solde à 0
   void Init();
   // Pour obtenir le solde courant
   float GetSolde() const;
   // Pour faire un retrait
   // Cette méthode ne doit pas effectuer le retrait si 
   // le montant est invalide ou si le solde est insuffisant
   void Retirer(float Montant);  
   // Pour faire un dépôt
   // Cette méthode ne doit pas effectuer le dépôt si le
   // montant est invalide
   void Deposer(float Montant);
};

Utilisez le programme principal suivant pour tester le bon fonctionnement de votre classe:

 

#include <iostream>
using namespace std;
int main()
{
   CCompte Cheque;
   
   Cheque.Init();
   Cheque.Deposer(100);  // Solde = 100 
   Cheque.Deposer(-20);  // Dépot invalide
   cout << Cheque.GetSolde() << endl; // Affiche 100	
   Cheque.Retirer(200); // Retrait invalide
   Cheque.Retirer(-20); // Retrait invalide
   Cheque.Retirer(60); // Solde = 40
   cout << Cheque.GetSolde() << endl; // Affiche 40
}   

Exercice 1.3

On souhaite implémenter une classe représentant un compteur entier. Le compteur a au départ la valeur 0. Le compteur ne peut varier que par pas de 1 (incrémentation ou décrémentation). Il ne faut pas que le compteur puisse descendre en bas de 0 ni monter en haut d'un million. Votre classe devra donc servir à représenter un petit compteur très simple qui ne peut faire que des pas de 1 et qui ne sort pas des limites prescrites. Votre classe devra donc contenir:

Il vous faudra créer un petit programme de test qui vous permettra de tester toutes les fonctionnalités et les limites de votre classe. Ce main devra donc déclarer un compteur, l'initialiser et faire des incrémentations et décrémentations pour montrer qu'elles fonctionnent tel que demandé. Utiliser une boucle pour faire plus d'un million d'incrémentations est très efficace, surtout si on n'affiche pas le résultat après chaque incrémentation!

Exercice 1.4

Programmez la classe CPosition qui permettra de conserver la position d'un personnage dans un jeu en deux dimensions. La classe CPosition a la représentation UML suivante:

UML

La méthode Init() permet de spécifier la position du personnage. Les méthodes de déplacement permettent de bouger le personnage d'une case à la fois. En aucun moment, la position du personnage ne doit sortir du tableau. C'est à dire que les valeur de x et de y ne peuvent être négatives ni supérieures à 512.

Créez un programme principal pour tester les fonctionnalités et les limites de votre classe.

Exercice 1.5

Voici un petit programme sous la forme procédurale classique:

#include <iostream>
using namespace std;
const float Tps = 0.05f;
const float Tvq = 0.09975f; // Depuis 2013
 
float CalculerTotal(float Prix, int Quantite)
{
   return Prix * Quantite;
}

float CalculerTaxes(float Prix, int Quantite)
{
   float Total = CalculerTotal(Prix, Quantite);
   float MontantTps = Total*Tps;
   float MontantTvq = Total*Tvq;  // Plus de surtaxe depuis 2013
   return MontantTps + MontantTvq;
}

int main()
{
   float Prix;
   int Quantite;

   cout << "Entrez le prix de l'article: ";
   cin >> Prix;
   cout << "Entrez la quantite: ";
   cin >> Quantite;
 
   cout << "Total: " << CalculerTotal(Prix, Quantite) << endl;
   cout << "Taxes: " << CalculerTaxes(Prix, Quantite) << endl;
}    

Transformez ce programme en un joli programme orienté objets.

Exercice 1.6

Cet exercice consiste à implanter une classe de conversion de température nommée CTemperature qui permet de conserver une température exprimée en système métrique ou anglais et de fournir au programme qui en fait la demande la valeur en degrés Celcius d’une température conservée en degrés Fahrenheit ou vice-versa. On peut aussi obtenir la valeur en degrés Celsius d’une température conservée en degrés Celsius ;-)
Cette classe présente une interface qui doit comporter au moins les membres suivants :

 

class CTemperature 
{
public:
   //  ----- Accesseurs publics
   double GetMetrique() const;
   double GetAnglaise() const;
   //  ----- Mutateurs publics
   void  SetMetrique(double Valeur);
   void  SetAnglaise(double Valeur);
private:
   //  ----- Attributs de la classe
   double ValeurMetrique_;    // valeur metrique de la temperature
   double ValeurAnglaise_;    // valeur anglaise  de la temperature
};

Voici une explication des services rendus par les méthodes de la classe :

C’est dire que la classe offre uniquement comme services publics à ses utilisateurs des mutateurs et des accesseurs.

Ainsi, si on conserve d’abord dans l’instance une valeur de 0 degré Celsius avec SetMetrique, faire appel au GetMetrique retourne la valeur 0 tandis qu’un appel à GetAnglaise retourne la valeur 32 puisque 0 degré Celsius vaut 32 dans l’échelle Fahrenheit. Par contre, si on fait ensuite appel à SetAnglaise pour conserver la valeur 95, le prochain appel à GetMetrique retournerait la valeur 35 puisque 95 degrés Fahrenheit équivaut à 35 dans l’échelle Celsius.

La conversion d’un système à l’autre sera prise en charge automatiquement par l’instance sans que l’utilisateur n’ait à se soucier de provoquer la conversion. Il n’a d’ailleurs aucune méthode publique à sa disposition pour ce faire. C’est la responsabilité de la classe de faire en sorte que les conversions s’effectuent au bon moment de façon à ce que les valeurs conservées dans l'objet soient toujours cohérentes.

La formule de conversion d’une température Fahrenheit vers une température en degrés Celcius est la suivante :

TempCelcius = (TempFahrenheit – 32) * 5 / 9;

La formule inverse de conversion de Celcius à Fahrenheit se déduit à partir de cette formule.

Finalement, vous devez écrire un programme principal qui teste toutes les fonctionnalités et limites de votre classe.