Fonctions de base en langage C/time.h
Présentation[modifier | modifier le wikicode]
Les premiers développeurs d'UNIX accordaient une grande importance aux calcul de dates et d'heures. Les fonctions déclarées dans time.h sont donc nombreuses.
La norme C laisse beaucoup de liberté quant à l'implémentation des fonctions de date. Pour les programmes qui nécessitent une grande précision, il faudra faire des tests pour évaluer le système cible sur ce point.
Type de données propres à time.h[modifier | modifier le wikicode]
- clock_t est un type entier permettant de représenter le temps écoulé depuis le démarrage du programme.
- time_t représente un entier signé positif après l’Epoch (1er janvier 1970 à 0 heure, 0 minute, 0 seconde sous UNIX) et négatif avant. Le code retour de la fonction en cas d'erreur est (time_t)-1. Cette valeur -1 représente aussi la dernière seconde de l'année 1969.
La structure tm[modifier | modifier le wikicode]
La structure tm permet de stocker un temps décomposé dans ses différents champs :
- int tm_sec : nombre de secondes (0 - 60), la seconde supplémentaire est nécessaire pour des recalages.
- int tm_min : minutes (0 - 59)
- int tm_hour : heures (0 - 23)
- int tm_mday : numéro du jour dans le mois (1 - 31)
- int tm_mon : numéro du mois dans l'année (0 - 11)
- int tm_year : année + 1900
- int tm_wday : numéro du jour dans la semaine (Dimanche = 0)
- int tm_yday : numéro du jour dans l'année (0 - 365)
- int tm_isdst : différent de 0 si l’heure d'été en vigueur
- char *tm_zone : abréviation d'une zone géographique concernant le temps. Exemple : CET pour Central European Time = UTC + 1 heure[1].
- long tm_gmtoff : décalage du temps UTC en secondes par rapport au 1er méridien.
Temps écoulé[modifier | modifier le wikicode]
Fonction clock()[modifier | modifier le wikicode]
La fonction clock_t clock(void) permet de connaître le nombre de fractions de temps machine écoulées depuis le début du programme. La valeur retournée peut être convertie en secondes en la divisant par la constante CLOCKS_PER_SEC. Elle peut servir à évaluer l'espace de temps entre deux évènements.
Un exemple d’utilisation :
/***************************************************************************
Nom ......... : clock.c
Role ........ : Recuperation du temps passe dans le programme.
Auteur ...... : Thierry46
Date Modif .. : 27/4/2008
Compilation : gcc -Wall -o test_clock clock.c
Exemple d’utilisation : ./test_clock
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
long clk_tck = CLOCKS_PER_SEC;
clock_t t1, t2;
int i;
int a = 0;
/* Recuperation du temps initial en "clock ticks" */
t1 = clock();
/* realisation du calcul */
for ( i = 0; i < 10000000; i++) {a++;}
(void)printf("a = %d\n", a);
/* Recuperation du temps final en "clock ticks" */
t2 = clock();
/* Affichage des différents temps et temps consommes */
(void)printf("Nb ticks/seconde = %ld, Nb ticks depart : %ld, "
"Nb ticks final : %ld\n",
clk_tck, (long)t1, (long)t2);
(void)printf("Temps consomme (s) : %lf \n",
(double)(t2-t1)/(double)clk_tck);
return EXIT_SUCCESS;
}
Donne à l'exécution sur mon système :
$ ./test_clock
a = 10000000
Nb ticks/seconde = 100, Nb ticks depart : 0, Nb ticks final : 4
Temps consomme (s) : 0.040000
Remarque : temps user et système[modifier | modifier le wikicode]
Pour obtenir des données comme le temps consommé par vos calculs (temps user), le temps utilisé lors des appels au système (temps système) et bien d'autres informations comme le fait la commande time (1) d'un système UNIX, vous pouvez utiliser la fonction UNIX getrusage. Cette fonction ne fait pas partie de time.h :
#include <sys/time.h>
#include <sys/resource.h>
/*...*/
ret = getrusage(RUSAGE_SELF, &usage);
if (ret == 0)
{
double tempsSystem = (double)usage.ru_stime.tv_sec +
(int)usage.ru_stime.tv_usec * 1E-6;
double tempsUser = (double)usage.ru_utime.tv_sec +
(int)usage.ru_utime.tv_usec * 1E-6;
(void)printf("system: %lf user: %lf\n"
"changements de contexte involontaires : %ld\n",
tempsSystem,
tempsUser,
usage.ru_nivcsw);
}
/*...*/
Date, heure et calendrier[modifier | modifier le wikicode]
Fonction time()[modifier | modifier le wikicode]
La fonction time_t time(time_t *tloc) retourne le nombre de secondes écoulées depuis le 1er janvier 1970 à 0 heure, 0 minute, 0 seconde sous UNIX, UTC.
Un exemple :
/***************************************************************************
Nom ......... : temps2.c
Role ........ : Fonctions de recuperation du temps.
Auteur ...... : Thierry46
Date ........ : 28/4/2008
Compilation : gcc -Wall -o temps2.exe temps2.c
Exemple d’utilisation : ./temps2.exe
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
time_t t1;
t1 = time(NULL);
if (t1 == (time_t)-1)
{
perror("time");
exit(EXIT_FAILURE);
}
(void)printf("%ld secondes, %s\n", t1, ctime(&t1));
return EXIT_SUCCESS;
}
Donne à l'exécution sur mon système :
$ ./temps2.exe
1209413960 secondes, Mon Apr 28 22:19:20 2008
Autres fonctions[modifier | modifier le wikicode]
- double difftime(time_t time1, time_t time0) Retourne le nombre de secondes qui séparent les temps time1 et time0.
- time_t mktime(struct tm *tm) Cette fonction accepte en paramètre l'adresse d'une structure tm dont vous aurez complété les champs. La fonction normalisera les champs et renseignera les champs tm_wday, tm_yday et tm_mday si tm_mon et tm_year sont connus. Elle retourne aussi le nombre de secondes depuis l’Epoch.
- char *asctime(const struct tm *tm) Convertit le temps décomposé tm en une chaîne de caractères du genre Mon Apr 28 22:19:20 2008.
- struct tm *localtime(const time_t *clock) Convertit le temps en secondes clock en un temps décomposé exprimé en temps local dans la structure tm.
- struct tm *gmtime(const time_t *clock) Convertit le temps en secondes clock en un temps décomposé exprimé en temps UTC dans la structure tm.
- char *ctime(const time_t *clock) = asctime(localtime(clock)).
- size_t strftime(char * restrict buf, size_t maxsize, const char * restrict format, const struct tm * restrict timeptr) convertit dans la chaîne buf, la date décomposée tm selon les directives indiquées par format.
Reference[modifier | modifier le wikicode]
