Discussion :

[Exanji]

Bonjour,
Je suis débutant en C++ (et dans la programmation en général), et je suis maintenant en train d'apprendre les classes. J'ai beaucoup de difficulté, et je voulais faire les exercices du livre pour mieux comprendre.
Je ne vois pas du tout comment faire ce problème:

"Il serait tout à fait raisonnable d'utiliser la classe Temps de la figure 7.8 afin de représenter le temps de façon interne par le nombre de secondes écoulées depuis minuit, plutôt qu'avec les trois valeurs d'entiers heure, minute, et seconde. Les clients pourraient utiliser les mêmes méthodes public et lire les mêmes résultats. Modifiez la classe Temps de la figure 7.8 pour y implanter le Temps comme étant le nombre de secondes écoulées depuis minuit et montrez qu'il n'y a aucun changement visible dans les qualités fonctionnelles pour les clients de la classe."

Et voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Fig. 7.8: temps6.h
// Appels de fonctions membres en cascade.
 
// Déclaration de la classe Temps.
// Fonctions membres définies dans temps6.cpp.
#ifndef TEMPS6_H
#define TEMPS6_H
 
class Temps {
public:
   Temps( int = 0, int = 0, int = 0 );  // constructeur par défaut.
 
   // fonctions d'ajustement (set).
   Temps &ajusterTemps( int, int, int ); // ajuste heure, minute, seconde.
   Temps &ajusterHeure( int );     // ajuste heure.
   Temps &ajusterMinute( int );    // ajuste minute.
   Temps &ajusterSeconde( int );   // ajuste seconde.
 
   // fonctions de lecture (get) (normalement déclarées const).
   int lectureHeure() const;       // renvoie heure.
   int lectureMinute() const;      // renvoie minute.
   int lectureSeconde() const;     // renvoie seconde.
 
   // fonctions d'affichage (normalement déclarées const).
   void afficherMilitaire() const; // affiche temps militaire.
   void afficherStandard() const;  // affiche temps standard.
private:
   int heure;                      // 0 - 23
   int minute;                     // 0 - 59
   int seconde;                    // 0 - 59
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
// Fig. 7.8: temps6.cpp
// Définitions des fonctions membres pour la classe Temps.
#include <iostream>
using std::cout;
#include "temps6.h"
 
// Fonction constructeur initialisant les données private.
// Appelle la fonction membre ajusterTemps pour ajuster
// les variables. Les valeurs par défaut sont de 0.
Temps::Temps( int hr, int min, int sec ) 
   { ajusterTemps( hr, min, sec ); }
 
// Ajuste les valeurs de heure, de minute et de seconde.
Temps &Temps::ajusterTemps( int h, int m, int s )
{
   ajusterHeure( h );
   ajusterMinute( m );
   ajusterSeconde( s ); 
   return *this;   // permet les appels en cascade.
}
// Ajuste la valeur de l'heure.
Temps &Temps::ajusterHeure( int h )
{
   heure = ( h >= 0 && h < 24 ) ? h: 0;
 
   return *this;   // permet les appels en cascade.
}
// Ajuste la valeur de la minute.
Temps &Temps::ajusterMinute( int m )
{
   minute = ( m >= 0 && m < 60 ) ? m: 0;
   return *this;   // permet les appels en cascade.
}
 
// Ajuste la valeur de la seconde.
Temps &Temps::ajusterSeconde( int s )
{
   seconde = ( s >= 0 && s < 60 ) ? s: 0;
 
   return *this;   // permet les appels en cascade.
}
 
// Lit la valeur de l'heure.
int Temps::lectureHeure() const { return heure; }
 
// Lit la valeur de la minute.
int Temps::lectureMinute() const { return minute; }
 
// Lit la valeur de la seconde.
int Temps::lectureSeconde() const { return seconde; }
 
// Affiche le temps en format militaire: HH:MM:SS.
void Temps::afficherMilitaire() const
{
   cout << ( heure < 10 ? "0": "" ) << heure << ":"
        << ( minute < 10 ? "0": "" ) << minute
               << ":" << ( seconde < 10 ? "0": "" ) << seconde;
}
 
// Affiche le temps en format standard: HH:MM:SS AM (ou PM).
void Temps::afficherStandard() const
{
   cout << ( ( heure == 0 || heure == 12 ) ? 12: heure % 12 ) 
        << ":" << ( minute < 10 ? "0": "" ) << minute 
        << ":" << ( seconde < 10 ? "0": "" ) << seconde
        << ( heure < 12 ? " AM": " PM" );
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Fig. 7.8: fig07_08.cpp
// Appels en cascade des fonctions membres mis ensemble
// avec le pointeur this.
#include <iostream>
 
using std::cout;
using std::endl;
 
#include "temps6.h"
 
int main()
{
   Temps t;
 
   t.ajusterHeure( 18 ).ajusterMinute( 30 ).ajusterSeconde( 22 );
   cout << "Temps militaire: ";
   t.afficherMilitaire();
   cout << "\nTemps standard: ";
   t.afficherStandard();
 
   cout << "\n\nNouveau temps standard: ";
   t.ajusterTemps( 20, 20, 20 ).afficherStandard();
   cout << endl;
 
 
   return 0;
}

On m'a dit qu'il serait plus facile d'utiliser modulo pour modifier ce programme, mais même là, je ne vois pas du tout quoi ET comment faire.
Cet exercise est du livre "C++ Comment programmer" de Deitel & Deitel.
Merci!

[koala01]

Salut,

Sans avoir la figure 7.8 devant les yeux, il est relativement difficile de te répondre, mais, si j'ai bien compris, il te propose de modifier ta classe temps de telle manière à ne pas considérer qu'il y a des heures, des minutes et des secondes clairement séparées, mais plutôt qu'il y a 60*60*24 secondes dans une journée.

Cela te permet d'avoir un seul membre représentant l'heure( et plus précisément le nombre de secondes écoulées depuis minuit), plutôt que d'avoir trois membres distincts.

La seule différence est donc qu'il faudra calculer à chaque fois les heures, les minutes et les secondes lorsque tu souhaites les obtenir.

Le calcul est, finalement, relativement simple:

• le nombre de secondes (de la minute en cours) correspond au reste de la division ("modulo") du nombre de secondes écoulées depuis minuit par 60 (car il revient à zéro toutes les 60 secondes )
• Le nombre de minutes (de l'heure en cours) correspond au résultat de la division du nombre de secondes écoulées depuis minuit par 60 (car il y a 60 secondes dans une minutes) dont on prend le modulo de 60 (car il revient à 0 toutes les 60 minutes)
• Enfin, le nombre d'heure correspond au résultat de la division du nombre de secondes écoulées depuis minuit par 3600 (car il y a 60 minutes de 60 secondes, soit 60*60 secondes, dans une heure)

A l'inverse, le nombre de secondes écoulées depuis minuit correspond à la somme:

• du nombre d'heure multiplié par 3600
• du nombre de minute multiplié par 60
• du nombre de secondes

Tu devrais donc pouvoir t'en sortir avec ces informations, non