PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 2 - Le cycle de vie

ATTENTION! Pour les exercices 2.1 à 2.3, il vous faut inscrire les réponses aux questions en commentaires directement dans votre code source.

Exercice 2.1 - Constructeur sans paramètre

Déclarez la classe suivante et programmez chacune des méthodes sans en ajouter:

 

const int AgeDefaut = 0;

const string NomDefaut = "Caramel";



class CChat

{

private:

   // Attributs

   int Age_;

   string Nom_;

public:

   // Mutateurs

   void SetAge(int Age);

   void SetNom(string Nom);

   // Accesseurs

   int GetAge() const;

   string GetNom() const;

};

Copiez le programme principal suivant:


int main()

{

   CChat MonChat;

   cout << MonChat.GetAge() << endl;

   cout << MonChat.GetNom() << endl;

}
  1. Quelles sont les valeurs initiales des attributs Age et Nom du chat?

  2. Ajoutez le constructeur sans paramètre suivant à la classe CChat. Pour ce faire, il faut ajouter les lignes suivantes à la partie publique de la déclaration de la classe:

    // Constructeur sans paramètre
    
    CChat();

    et les lignes suivantes aux définitions:

    CChat::CChat()
    
    { 
    
       SetAge(AgeDefaut); 
    
       SetNom(NomDefaut); 
    
    } 

    Exécutez à nouveau le programme. Quelles sont les valeurs initiales des attributs Age et Nom?

  3. À l'aide du débuggeur, déterminez l'endroit exact du programme principal où le constructeur est appelé.

  4. Remplacez la déclaration de l'objet MonChat par la déclaration suivante:

    CChat MonChat();

    Tentez de générer la solution. Qu'observez-vous? Pouvez-expliquer ce résultat?

  5. Supprimez la déclaration CChat MonChat(); et déclarez plutôt un tableau de 10 chats. Pour chacun des chats, affichez l'age et le nom du chat. Que remarquez-vous? Combien de fois le constructeur sans paramètre a-t-il été appelé?

Exercice 2.2 - Constructeurs avec paramètres

Ajoutez les déclarations suivantes à la classe CChat de l'exercice 2.1:


// Constructeur avec 1 paramètre

CChat(int Age);

// Constructeur avec 1 paramètre

CChat(string Nom);

// Constructeur avec 2 paramètres

CChat(int Age, string Nom);

Ajoutez les lignes suivantes aux définitions de la classe CChat:


CChat::CChat(int Age)

{

   SetAge(Age); 

   SetNom(NomDefaut); 

}

CChat::CChat(string Nom)

{

   SetAge(AgeDefaut); 

   SetNom(Nom); 

}

CChat::CChat(int Age, string Nom)

{

   SetAge(Age); 

   SetNom(Nom); 

}

Et utilisez le programme principal suivant:



int main()

{

   CChat Chat1;

   CChat Chat2(5);

   CChat Chat3("Mozart");

   CChat Chat4(7, "Felix");

}
  1. À l'aide du debuggeur ou de sorties à la console, identifiez le constructeur qui est appelé pour chacun des chats.

  2. À l'aide du debuggeur ou de sorties à la console, déterminez les valeurs des attributs Age et Nom de chacun des chats après la construction de l'objet.

  3. Déclarez un tableau de 10 chats puis, supprimez (ou mettez en commentaires) la déclaration et la définition du constructeur sans paramètre. Tentez de générer la solution. Qu'observez-vous? Pouvez-expliquer ce résultat?

 

Exercice 2.3 - Constructeur avec paramètres par défaut

Supprimez toutes les déclarations et toutes les définitions des constructeurs de la classe CChat élaborée aux numéros précédents, puis ajouter la déclaration du constructeur suivant:

// Constructeur avec paramètres par défaut

CChat(int Age=AgeDefaut, string Nom=NomDefaut);


Ainsi que sa définition:

CChat::CChat(int Age, string Nom)

{

   SetAge(Age); 

   SetNom(Nom); 

}

et le programme principal suivant:

int main()

{

   CChat Chat1;

   CChat Chat2(5);

   CChat Chat3(7, "Felix");

}
  1. Pour chacun des chats, identifez le constructeur qui est appelé et la valeur de chacun des attributs Age et Nom après la construction de l'objet.

  2. Ajoutez la déclaration et la définition du constructeur sans paramètre. Tentez de générer la solution. Qu'observez-vous? Pouvez-expliquer ce résultat?

  3. Ajoutez la déclaration et la définition du constructeur à 1 paramètre CChat(int Age); Tentez de générer la solution. Qu'observez-vous? Pouvez-expliquer ce résultat?

  4. Ajoutez la déclaration et la définition du constructeur à 2 paramètres CChat(int Age, string Nom); Tentez de générer la solution. Qu'observez-vous? Pouvez-expliquer ce résultat?

Exercice 2.4 - Le rectangle

Programmez la classe CRectangle de façon à ce que le programme principal suivant:

int main()

{

   CRectangle Rect1;

   CRectangle Rect2(2);

   CRectangle Rect3(2,3);

   CRectangle Rect4(Rect3);

   cout << "Aire du rectangle 1: " << Rect1.Aire() << endl;

   cout << "Aire du rectangle 2: " << Rect2.Aire() << endl;

   cout << "Aire du rectangle 3: " << Rect3.Aire() << endl;

   cout << "Aire du rectangle 4: " << Rect4.Aire() << endl;

}

donne la sortie à la console suivante:

Aire du rectangle 1: 1

Aire du rectangle 2: 2

Aire du rectangle 3: 6

Aire du rectangle 4: 6      


Note
: Bien que le constructeur de copie ne soit pas rigoureusement nécessaire, il vous faut tout de même le programmer!

Exercice 2.5 - Les étoiles

Programme la classe CEtoile de façon à ce que le programme principal suivant:


int main()

{

   CEtoile e1;

   cout << "de besoin d'un ";

   CEtoile e2(e1);

   cout << "Quand t'en a ";

   CEtoile e3(5);

   cout << "dans le ";

   e2.Afficher();

}

donne la sortie à la console suivante:

As-tu de besoin d'un cinq etoiles

Quand t'en a cinq milliards dans le ciel???

Note: le destructeur doit afficher au moins un caractère à l'écran et il est interdit d'utiliser une instruction comme system("cls") pour effacer la console!

Exercice 2.6 - La carte de crédit

Programmez la classe suivante:

const float TauxDefaut   = 0.195f; // 19,5%

const float SoldeDefaut  = 0.0f;

const float LimiteDefaut = 1000.0f;





class CCarteDeCredit

{

private:

   // Attributs

   float Solde_;

   float Taux_;

   float Limite_;

   

   // Mutateurs

   // Les mutateurs sont privés parce qu'on ne veut pas qu'ils soient accessibles 

   // de l'extérieur de la classe

   void SetSolde(float Solde);

   void SetTaux(float Taux);

   void SetLimite(float Limite);

   

public:

   // Accesseurs

   float GetSolde() const;

   float GetTaux() const;

   float GetLimite() const;

   // Pour payer une partie ou la totalité du solde de la carte de crédit

   // La méthode doit vérifier si le montant est valide

   void Payer(float Montant);

   // Pour ajouter un achat sur la carte de crédit

   // La méthode doit vérifier que le montant est valide et que la limite

   // n'est pas dépassée

   void AjouterAchat(float Montant);

   // Retourne le montant des intérêts qu'il faut payer

   float CalculerInterets() const; 

};      

Ajoutez le destructeur (qui ne fait rien pour l'instant!) et les constructeurs suivants:

  1. le constructeur sans paramètre;
  2. un constructeur qui prend la limite en paramètre;
  3. un constructeur qui prend la limite et le taux d'intérêts en paramètres;
  4. un constructeur qui prend la limite, le taux d'intérêts et le solde initial en paramètres;
  5. et le constructeur de copie.

Écrivez un programme principal qui permet de tester toutes les fonctionnalités de la classe et toutes les façons de construire des objets de cette classe.

Exercice 2.7

Vous devez écrire une classe qui permet de représenter des combinaisons de 6/49. Pour le 6/49, une combinaison est composée de 6 chiffres distincts de 1 à 49. Vous avez donc choisi de représenter la combinaison comme un tableau automatiques de 6 entiers. Voici l’interface publique de la classe que vous devez implanter ainsi que les attributs minimaux que vous devez utiliser :


const int NbElements = 6;



class CCombinaison  

{

public:

   



   //----  La méthode Afficher permet  d'afficher la combinaison générée

   //      automatiquement par l'objet à la console

   //------------------------------------------------------------------

   void Afficher();

   

   //---- La méthode  Generer() génère une combinaison en choisissant 

   //     aléatoirement 6 chiffres différents de 1 à  49

   //------------------------------------------------------------------

 	void Generer();



   

   //---- La méthode GetElement retourne un  des chiffres de la combinaison

   //     en fonction de la valeur passée en paramètre, qui peut varier 

   //     de 0 à 5.

   //------------------------------------------------------------------

 	int GetElement(int i) const;



   //----  Constructeurs et le destructeur

   CCombinaison(int n1, int n2, int n3, int n4, int n5, int n6);

   CCombinaison(int TabElements[]);

   CCombinaison();

   CCombinaison(const CCombinaison& Original);

   ~CCombinaison();



private:

   // Implantation d'un tableau automatique 

   // permettant de retenir les nombres de la combinaison

   int TabCombinaison_[NbElements];             

};

Il va de soi qu’il vous est permis d’ajouter tout ce que vous désirez à cette interface mais les éléments mentionnés doivent être présents dans votre classe.

Voici un aperçu des caractéristiques des constructeurs :

  1. Le constructeur sans paramètre provoque la création d’une nouvelle combinaison de 6/49 en générant aléatoirement les six nombres différents requis pour la combinaison et en les classant en ordre croissant.
  2. Un constructeur reçoit un tableau contenant les entiers représentant les nombres de la combinaison. Le constructeur doit donc prendre ces nombres et les conserver dans son tableau en supposant que les nombres reçus forment une combinaison valide.
  3. Un autre constructeur reçoit les nombres qui forment la combinaison. Encore une fois, le constructeur doit prendre ces nombres et les conserver dans son tableau en supposant que les nombres reçus forment une combinaison valide.
  4. Un constructeur de copie est également nécessaire. 

Votre classe doit correctement faire appel au générateur de nombres aléatoires pour créer des combinaisons aléatoires lors de l’exécution. Finalement, notez qu’une combinaison doit être ordonnée et présenter ses nombres du plus petit au plus grand.