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;
}
} |
Partager