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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
| #include <stdlib.h>
#include <stdio.h>
//--- définition du type stime -------------------------------------------------
// Le type stime est capable de mémoriser une donnée temporelle limitée à une
// période de HOUR_PER_DAY heures et à une précision d'un centième de
// seconde. La plus petite donnée mémorisable correspond à 0 heure, 0 minute,
// 0 seconde, 0 centième de seconde, la plus grande à
// (HOUR_PER_DAY - 1) heures, (MIN_PER_HOUR - 1) minutes,
// (SEC_PER_MIN - 1) secondes, (HSEC_PER_SEC - 1) centièmes de seconde
typedef struct {
int hour;
int min;
int sec;
int hsec;
} stime;
#define HOUR_PER_DAY 24
#define MIN_PER_HOUR 60
#define SEC_PER_MIN 60
#define HSEC_PER_SEC 100
#define FUN_SUCCESS 0
#define FUN_FAILURE -1
//--- déclaration des opérations sur le type stime -----------------------------
typedef enum { NEW_LINE, CARRIAGE_RETURN } stime_print_ending;
// stime_pack : initialise la variable pointée par stptr à partir des données
// h heures, m minutes, s secondes et hs centièmes de seconde fournies.
// Renvoie 0 en cas de succès et une valeur non nulle en cas d'échec. En cas
// d'échec, la variable pointée par stptr n'est pas modifiée
int stime_pack(int h, int m, int s, int hs, stime *stptr);
// stime_unpack : restitue sous la forme heures, minutes, secondes et centièmes
// de seconde la donnée temporelle mémorisée par la variable pointée par
// stptr en l'affectant aux variables pointées par hptr, mptr, sptr et hsptr
void stime_unpack(const stime *stptr,
int *hptr, int *mptr, int *sptr, int *hsptr);
// stime_scan : initialise la variable pointée par stptr à partir des données
// heures, minutes, secondes et centièmes de seconde lues sur l'entrée
// standard. Renvoie 0 en cas de succès et une valeur non nulle en cas
// d'échec. En cas d'échec, la variable pointée par stptr n'est pas modifiée
int stime_scan(stime *stptr);
// stime_print : écrit sur la sortie standard la décomposition heures, minutes,
// secondes et centièmes de seconde de la donnée temporelle mémorisée par la
// variable pointée par stptr. Le format de sortie est "hh:mm:ss:hs".
// L'affichage est suivi du caractère nouvelle ligne '\n' ou retour charriot
// '\r' selon que ending vaut NEW_LINE ou CARRIAGE_RETURN
void stime_print(const stime *stptr, stime_print_ending ending);
// stime_incr : augmente la donnée temporelle mémorisée par la variable pointée
// par stptr d'un centième de seconde au modulo HOUR_PER_DAY heures, avec, le
// cas échéant, passage de la plus grande donnée mémorisable à la plus petite
void stime_incr(stime *stptr);
// stime_decr : diminue la donnée temporelle mémorisée par la variable pointée
// par stptr d'un centième de seconde au modulo HOUR_PER_DAY heures, avec, le
// cas échéant, passage de la plus petite donnée mémorisable à la plus grande
void stime_decr(stime *stptr);
// stime_compar : renvoie 0, une valeur strictement négative ou strictement
// positive selon que la donnée temporelle mémorisée par la variable pointée
// par stptr1 est égale, strictement inférieure ou strictement supérieure à
// celle mémorisée par la variable pointée par stptr2
int stime_compar(const stime *stptr1, const stime *stptr2);
int main(void){
stime *stptr = NULL;
stime_scan(stptr);
stime_print(stptr, NEW_LINE);
return EXIT_SUCCESS;
}
int stime_pack(int h, int m, int s, int hs, stime *stptr){
if (!(0 <= h && h <= HOUR_PER_DAY)
&& (0 <= m && m <= MIN_PER_HOUR)
&& (0 <= s && s <= SEC_PER_MIN)
&& (0 <= hs && hs <= HSEC_PER_SEC)){
return FUN_FAILURE;
} else {
stptr -> hour = h;
stptr -> min = m;
stptr -> sec = s;
stptr -> hsec = hs;
return FUN_SUCCESS;
}
}
void stime_unpack(const stime *stptr,
int *hptr, int *mptr, int *sptr, int *hsptr){
*hptr = stptr -> hour;
*mptr = stptr -> min;
*sptr = stptr -> sec;
*hsptr = stptr -> hsec;
}
int stime_scan(stime *stptr){
int h;
int m;
int s;
int hs;
if (scanf("%d%d%d%d", &h, &m, &s, &hs) != 4){
return FUN_FAILURE;
} else {
stime_pack(h, m, s, hs, stptr);
return FUN_SUCCESS;
}
}
void stime_print(const stime *stptr, stime_print_ending ending){
int *hptr = NULL;
int *mptr = NULL;
int *sptr = NULL;
int *hsptr = NULL;
stime_unpack(stptr, hptr, mptr, sptr, hsptr);
printf("%d : %d : %d : %d", *hptr, *mptr, *sptr, *hsptr);
if (ending == NEW_LINE){
printf("\n");
}else{
printf("\r");
}
}
void stime_incr(stime *stptr){
stptr -> hsec += 1;
stptr -> sec += stptr -> hsec / HSEC_PER_SEC;
stptr -> min += stptr -> sec / SEC_PER_MIN;
stptr -> hour += stptr -> min / MIN_PER_HOUR;
stptr -> hour %= HOUR_PER_DAY;
stptr -> min %= MIN_PER_HOUR;
stptr -> sec %= SEC_PER_MIN;
stptr -> hsec %= HSEC_PER_SEC;
}
void stime_decr(stime *stptr){
stptr -> hsec -= 1;
stptr -> sec -= stptr -> hsec / HSEC_PER_SEC;
stptr -> min -= stptr -> sec / SEC_PER_MIN;
stptr -> hour -= stptr -> min / MIN_PER_HOUR;
stptr -> hour %= HOUR_PER_DAY;
stptr -> min %= MIN_PER_HOUR;
stptr -> sec %= SEC_PER_MIN;
stptr -> hsec %= HSEC_PER_SEC;
}
int stime_compar(const stime *stptr1, const stime *stptr2){
if (stptr1 == stptr2){
return FUN_SUCCESS;
} else if (stptr1 < stptr2){
return FUN_FAILURE;
} else {
return 1;
}
} |
