FAQ CConsultez toutes les FAQ
Nombre d'auteurs : 28, nombre de questions : 175, création le 11 janvier 2013
Sommaire→Divers→Gestion des dates et heures- Qu'est-ce que l'heure système ?
- Qu'est-ce que l'heure locale ?
- Comment obtenir la date et l'heure courante ?
- Comment décomposer une date ?
- Comment formater une date sous un format spécifique ?
- Comment convertir une date en chaîne de caractères ?
- Comment soustraire deux dates ?
- Comment connaître l'heure système (Windows) ?
- Comment connaître l'heure locale (Windows) ?
- Comment chronométrer des temps d'exécution ?
L'heure système est la date (date système) et l'heure (heure système) utilisées en interne par le système. La majorité des systèmes utilisent le temps universel comme heure système.
L'heure locale est la date (date locale) et l'heure (heure locale) qu'il fait dans un point particulier du globe. Elle peut se calculer à l'aide d'une formule mathématique qui fait entrer en jeu l'heure système et les coordonnées de ce point.
La fonction time permet d'obtenir la date et l'heure courante (heure système).
#include <time.h>
time_t t = time(NULL); /* t contient maintenant la date et l'heure courante */
La valeur retournée peut également être récupérée via un pointeur vers un buffer assez grand pour la contenir. Voici donc une deuxième méthode :
#include <time.h>
time_t t;
time(&t); /* t contient maintenant la date et l'heure courante */
La fonction time fournit la date système sous forme d'un nombre de secondes écoulées depuis une date précise. Une telle date est appelée un 'timestamp'. La majorité des systèmes utilisent le 01/01/1970 à 00:00:00 UTC comme référence. Les fonctions gmtime et localtime permettent de décomposer cette date en année, mois, jour, heure, minute et seconde en remplissant une structure struct tm définie par :
struct tm
{
int tm_sec; /* secondes (0,59) */
int tm_min; /* minutes (0,59) */
int tm_hour; /* heures depuis minuit (0,23) */
int tm_mday; /* jour du mois (0,31) */
int tm_mon; /* mois depuis janvier (0,11) */
int tm_year; /* années écoulées depuis 1900 */
int tm_wday; /* jour depuis dimanche (0,6) */
int tm_tm_yday; /* jour depuis le 1er janvier (0,365) */
int tm_isdst;
};
Voici donc un petit programme affichant la date et l'heure courante (locale) selon le format français :
#include <stdio.h>
#include <time.h>
const char * NomJourSemaine[] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
const char * NomMois[] = {"janvier", "fevrier", "mars" , "avril" , "mai" , "juin" ,
"juillet", "aout" , "septembre", "octobre", "novembre", "decembre"};
int main(void)
{
time_t timestamp;
struct tm * t;
timestamp = time(NULL);
t = localtime(&timestamp);
/* Affiche la date et l'heure courante (format francais) */
printf("Nous sommes %s, ", NomJourSemaine[t->tm_wday]);
printf("le %02u %s %04u, ", t->tm_mday, NomMois[t->tm_mon], 1900 + t->tm_year);
printf("et il est %02uh %02umin %02usec.\n", t->tm_hour, t->tm_min, t->tm_sec);
return 0;
}
Pour obtenir l'heure système, il suffit de remplacer localtime par gmtime.
La fonction strftime permet de formater une date en appliquant le même principe de chaîne de formatage que sprintf.
#include <time.h>
size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);
Le premier argument de la fonction est le pointeur vers le tampon destiné à recevoir la chaîne formattée et le second un entier indiquant la taille de ce tampon. Le paramètre format est une chaîne de caractère décrivant le format souhaité dont voici les spécificateurs de format :
+------+-------------------------------------------------------------+
| Code | Format correspondant |
+------+-------------------------------------------------------------+
| %a | Nom du jour en abrégé |
| %A | Nom du jour complet |
| %b | Nom du mois en abrégé |
| %B | Nom du mois complet |
| %c | MM/JJ/AA HH:MM:SS |
| %d | Numéro du jour dans le mois (01 à 31) |
| %H | Heure sur 24 heures (00 à 23) |
| %I | Heure sur 12 heures (01 à 12) |
| %m | Numéro du mois dans l'année (01 à 12) |
| %M | La minute (0 à 59) |
| %p | AM ou PM suivant la partie de la journée |
| %S | La seconde (0 à 59) |
| %u | Numéro du jour de la semaine (1 (lun.) à 7 (dim.)) |
| %w | Numéro du jour de la semaine (0 (dim.) à 6 (sam.)) |
| %x | MM/JJ/AA |
| %X | HH:MM:SS |
| %y | Année sur deux chiffres |
| %Y | Année sur quatres chiffres |
| %Z | Nom du fuseau horaire |
| %% | Le caractère % |
+------+-------------------------------------------------------------+
Voici un exemple pour illustrer cela :
#include <stdio.h>
#include <time.h>
int main(void)
{
char buffer[256];
time_t timestamp = time(NULL);
strftime(buffer, sizeof(buffer), "%A %d %B %Y - %X.", localtime(×tamp));
printf("%s\n", buffer);
return 0;
}
La fonction ctime permet de convertir un timestamp en une chaîne de caractères, en ajustant la date à la date et l'heure locales.
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t t = time(NULL);
printf("%s\n", ctime(&t));
return 0;
}
La fonction asctime permet de convertir une structure struct tm en une chaîne de caractères représentant la même date. Le programme précédent est donc équivalent à :
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t t = time(NULL);
printf("%s\n", asctime(localtime(&t)));
return 0;
}
La fonction difftime permet de soustraire deux dates. Ces dernières doivent être sous la forme d'une struture de type time_t, que l'on peut obtenir, soit par l'intermédiaire de la fonction time pour la date du jour, soit avec la fonction mktime. Voici un exemple qui calcule le nombre de secondes écoulées depuis le 1er Janvier 2000 minuit :
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t today;
struct tm an2000;
an2000.tm_mday = 1; /* 1er */
an2000.tm_mon = 0; /* janvier */
an2000.tm_year = 100; /* 2000 (2000 - 1900) */
an2000.tm_hour = 0; /* 0 heure */
an2000.tm_min = 0; /* 0 minute */
an2000.tm_sec = 0; /* 0 seconde */
today = time(NULL);
printf("Il s'est coule %g secondes depuis le 1er janvier 2000 minuit.\n",
difftime(today, mktime(&an2000)));
return 0;
}
L'unité de temps utilisée par la fonction time est la seconde. Windows permet de connaître l'heure système jusqu'à la milliseconde grace à la fonction GetSystemTime.
void GetSystemTime(SYSTEMTIME *lpSystemTime);
En utilisant GetLocalTime au lieu de GetSystemTime. Le programme suivant affiche la date et l'heure locales en utilisant cette fonction.
#include <stdio.h>
#include <windows.h>
int main(void)
{
SYSTEMTIME Time;
GetLocalTime(&Time);
printf("Nous sommes le : %02d/%02d/%04d.\n",
Time.wDay, Time.wMonth, Time.wYear);
printf("Et il est : %02dh %02dmn %02ds %03dms.\n",
Time.wHour, Time.wMinute, Time.wSecond, Time.wMilliseconds);
return 0;
}
La fonction clock() permet de mesurer le temps CPU en ticks d'horloge. Pour obtenir ce temps en seconde, il suffit de convertir à l'aide de CLOCKS_PER_SEC.
#include <stdio.h>
#include <time.h>
int main(void)
{
clock_t start, end;
double elapsed;
start = clock(); /* Lancement de la mesure */
/* ... */ /* Faire quelque chose */
end = clock(); /* Arret de la mesure */
elapsed = ((double)end - start) / CLOCKS_PER_SEC; /* Conversion en seconde */
printf("%.2f secondes entre start et end.\n", elapsed);
return 0;
}
Sous Windows, il y a aussi la fonction GetTickCount() qui retourne le nombre de millisecondes écoulées depuis le lancement du système. Malheureusement GetTickCount() n'a généralement une précision que de l'ordre de quelques ms et si on veut mesurer des temps plus faibles (temps d'execution d'une fonction, mesure du framerate dans les jeux, ...), il vaudra mieux utiliser la fonction QueryPerformanceCounter. La précision du compteur utilisée par cette fonction peut être connue à l'aide de QueryPerformanceFrequency. Ces deux fonctions travaillent sur des entiers larges (LARGE_INTERGER), une union représentant un entier de 64 bits. Le membre QuadPart de cette union permet d'accéder intégralement à l'entier qu'il représente.
#include <stdio.h>
#include <windows.h>
int main(void)
{
LARGE_INTEGER start, end, freq;
double elapsed;
QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&start); /* Lancement de la mesure */
/* ... */ /* Faire quelque chose */
QueryPerformanceCounter(&end); /* Arret de la mesure */
elapsed = (1000.0 * (end.QuadPart - start.QuadPart)) / freq.QuadPart; /* Conversion en millsecondes */
printf("%.0f millisecondes entre start et end.\n", elapsed);
return 0;
}