Gestion du temps en C




        



Le fichier d'en tête time.h propose au programmeur plusieurs méthodes permettant la gestion du temps.
Il existe deux moyen de manipuler le temps en C :
  • La manipulation de la date et / ou de l'heure classique
  • La détermination du temps d'utilisation du processeur lors de l'exécution d'un programme


Sommaire

1. Manipulation de la date et / ou de l'heure
2. time
3. ctime, gmtime, localtime
4. asctime, mktime
5. difftime
6. strftime
7. Temps utilisé par le processeur


Manipulation de la date et / ou de l'heure

        Les fonctions asctime, time, cmtime, difftime, gmtime, localtime, mktime, strftime, vous nous permettre un traitement efficace. Voyons les en détail. 


/* Function prototypes */

_CRTIMP char * __cdecl asctime(const struct tm *);
_CRTIMP char * __cdecl ctime(const time_t *);
_CRTIMP clock_t __cdecl clock(void);
_CRTIMP double __cdecl difftime(time_t, time_t);
_CRTIMP struct tm * __cdecl gmtime(const time_t *);
_CRTIMP struct tm * __cdecl localtime(const time_t *);
_CRTIMP time_t __cdecl mktime(struct tm *);
_CRTIMP size_t __cdecl strftime(char *, size_t, const char *,
        const struct tm *);
_CRTIMP char * __cdecl _strdate(char *);
_CRTIMP char * __cdecl _strtime(char *);
_CRTIMP time_t __cdecl time(time_t *);


time

        La routine time a pour prototype : 


time_t time(time_t *ptr);

        Le type time_t est en fait un typedef pour unsigned long défini ainsi dans time.h : 


#ifndef _TIME_T_DEFINED
typedef long time_t;        /* time value */
#define _TIME_T_DEFINED     /* avoid multiple def's of time_t */
#endif

        En fait la fonction time retourne le temps passé depuis le 1er janvier 1970 en secondes (norme POSIX). Elle retourne -1 en cas d'echec.
Si ptr n'est pas egal à null alors la valeur retourneée par la fonction est aussi affectée à *ptr.


ctime, gmtime, localtime

        Les fonctions ctime, gmtime et localtime sont très similaires dans leur fonctionnement. Elles ont pour prototype : 


char *ctime(const time_t *ptr);
struct tm *gmtime(const time_t*ptr);
struct tm *localtime(const time_t *timeptr);

        Toutes ces fonctions comme on le voit acceptent une valeur de type time_t (en fait un unsigned long comme vu précédemment) retournée par la méthode time.
Voyons ce que ces trois méthodes réalisent à partir de cette valeur

ctime

La routine ctime retourne sous la forme d'uine chaine de caractère la date d'une manière formatée et plus explicite par exemple : 


Sat Dec 15 12 : 02 : 41 2001

        ce qui est plus lisible que : 


36578367

        

gmtime et cmtime

Ces deux fonctions retourne un pointeur sur une structure tm initialisée.
La structure tm dispose d'un grand nombre de champs contenant des valeurs pouvant être exploitée par le programmeur 


#ifndef _TM_DEFINED
struct tm {
        int tm_sec;     /* secondes dans la minute courante - [0,59] */
        int tm_min;     /* minutes dans l'heure courante - [0,59] */
        int tm_hour;    /* heures depuis minuit - [0,23] */
        int tm_mday;    /* jours du mois - [1,31] */
        int tm_mon;     /* nb de mois depuis janvier- [0,11] */
        int tm_year;    /* nb d'années depuis 1900 */
        int tm_wday;    /* jours depuis dimanche - [0,6] */
        int tm_yday;    /* jours depuis le 1 janvier 1 - [0,365] */
        int tm_isdst;   /* heure d'été (1 : oui, 0 : non */
        };
#define _TM_DEFINED
#endif

        Cette structure sera initialisée selon le temps universel (GMT) en utilisant la fonction gmtime et selon le temlps local avec la fonction localtime.
Voyons un premier exemple : 


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main( void )
{
    //valeur qui va contenir le temps en secondes
    //écoulé depuis le 01/01/1970
    time_t time_of_day;

    //on cherche le temps écoulé
    time_of_day = time( NULL );

    //on affiche ce temps d'une manière explicite sous la forme
    // d'une string grâce à ctime
    printf( "Nous sommes le : %s", ctime( &time_of_day ) );
    return 0;
  }

        produit la sortie 


Nous sommes le: Wed Jun 30 09:09:33 1999

        et un second : 


#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main( void )
{
  //notre temps en secondes depuis 01/01/1970
  time_t temps;

  //la structure contenant bcp d'infos sur le temps
  struct tm *infos;

  //la chaine qui va conteir la date d'une manière explicite
  char * date;
  
  //récuperer le temps écoulé depuis le 01/01/1970
  temps = time(NULL);  

  //inscrire cette date d'une manière explicite dans la chaine date
  date = ctime(&temps);

  //récuper les infos sur le temps
  infos = localtime(&temps);
  
  //afficher le tout
  printf("temps passes depuis le 01/01/1970 en secondes : %ld\n", temps);

  printf("Nous sommes le : %s\n", date);

  printf("seconde : %d\n", infos->tm_sec);
  printf("minute : %d\n", infos->tm_min);
  printf("heure : %d\n", infos->tm_hour);
  printf("jour dans le mois : %d\n", infos->tm_mday);
  printf("jour dans l'annee : %d\n", infos->tm_yday);
  printf("mois : %d\n", infos->tm_mon);
  printf("annee : %d\n", infos->tm_year);
  printf("jours depuis dimanche : %d\n", infos->tm_wday);
  printf("heure d'ete : 0 non, 1 oui : %d\n", infos->tm_isdst);

  return 0;
}

        qui produit la sortie 


Lord Asriel : gcc temps.c  -o temps
Lord Asriel : temps
temps passes depuis le 01/01/1970 en secondes : 984789417
Nous sommes le : Sat Mar 17 00:36:57 2001

seconde : 57
minute : 36
heure : 0
jour dans le mois : 17
jour dans l'annee : 75
mois : 2
annee : 101
jours depuis dimanche : 6
heure d'ete : 0 non, 1 oui : 0
Lord Asriel :


asctime, mktime

        Les fonctions asctime et mktime ont pour prototype : 


char * asctime(const struct tm *ptr);
time_t *mktime(const struct tm *ptr);

        Ces fonctions acceptent toutes les deux un pointeur sur une structure de type tm préalablement intialisée.

asctime

La fonction asctime retourne l'adresse d'une chaîne de caractère contenant la représentation de la date d'une manière explicite (comme vu précédemment avec cmtime).

mktime

La fonction mktime retourne le tmeps correspondant au contenu de la structure tm. Elle effectue l'opération inverse des fonctions gmtime et localtime en revnoyant une valeur de type time_t (en fait unsigned long).


difftime

        La fonction difftime a pour prototype : 


double difftime(time_t a, time_t b);

        Elle retourne la différence de temps entre a et b (a-b) exprimés en secondes. 


#include <stdio.h>
#include <time.h>
#include <stdlib.h>

/**
 * fonction contenant des boucles
 * inutiles faisant un traitement
 * inutile permettant de perdre du temps
 */
void compute( void )
{
    int i, j;

    //boucles inutiles
    for( i = 1; i <= 20; i++ ) {
        for( j = 1; j <= 20; j++ ) {
            printf( "%3d ", i * j );
        }
        printf( "\n" );
    }
}

int main( void )
{
    //valeurs contenant le temps de départ
    //et de fin du programme
    time_t start_time, end_time;

    //on récupere la date de départ
    start_time = time( NULL );

   //on fait un traitement
    compute();

    //on récupère la date de fin
    end_time = time( NULL );

    //et on affiche le temps passé
    printf("temps passé : %f secondes\n",
        difftime( end_time, start_time ) );

    return 0;
}

        Renvoie la sortie 


Lord Asriel : gcc temps.c  -o temps
Lord Asriel : temps
  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
  2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40
  3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60
  4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68  72  76  80
  5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90  95 100
  6  12  18  24  30  36  42  48  54  60  66  72  78  84  90  96 102 108 114 120
  7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 112 119 126 133 140
  8  16  24  32  40  48  56  64  72  80  88  96 104 112 120 128 136 144 152 160
  9  18  27  36  45  54  63  72  81  90  99 108 117 126 135 144 153 162 171 180
 10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180 190 200
 11  22  33  44  55  66  77  88  99 110 121 132 143 154 165 176 187 198 209 220
 12  24  36  48  60  72  84  96 108 120 132 144 156 168 180 192 204 216 228 240
 13  26  39  52  65  78  91 104 117 130 143 156 169 182 195 208 221 234 247 260
 14  28  42  56  70  84  98 112 126 140 154 168 182 196 210 224 238 252 266 280
 15  30  45  60  75  90 105 120 135 150 165 180 195 210 225 240 255 270 285 300
 16  32  48  64  80  96 112 128 144 160 176 192 208 224 240 256 272 288 304 320
 17  34  51  68  85 102 119 136 153 170 187 204 221 238 255 272 289 306 323 340
 18  36  54  72  90 108 126 144 162 180 198 216 234 252 270 288 306 324 342 360
 19  38  57  76  95 114 133 152 171 190 209 228 247 266 285 304 323 342 361 380
 20  40  60  80 100 120 140 160 180 200 220 240 260 280 300 320 340 360 380 400
temps passé: 20.000000 secondes
Lord Asriel :


strftime

        La fonction strftime dont le prototype est : 


size_t strftime(char *s, size_t max, const char *format, const struct tm *ptr);

        fonctionne d'une manière analogue à sprintf mais en plus compliqué.
la fonction strftime transforme les informations contenue dans la structure de type tm suivant le format fmt (analogue à celui de printf) et place le résultat dans la chaîne de caractère s.
La chaine format consiste en une suite de 0 ou plusieurs directives et de caractères ordinaires.
Rappeons que, comme avec printf, une directive consiste d'un % suivit d'un caractère qui détermine la subtitution qui doit être opéré.
Tous les caractères ordinaires sont recopiés tels quels dans la chaîne s. Cette dernière étant terminée par nu '\0'.
La maximum de caractères copiés dans s ne devant pas dépasser la valeur contenue dans maxsize.

Les différentes directives

%a nom du jours en abrévié
%A nom du jour complet.
%b nom du mois en abrévié.
%B nom du mois complet.
%c représentation appropriée de la date et l'heure locale.
%d jour du mois sous la forme d'un entier (01-31).
%D date avec le format mm/dd/yy (mois, jours, an).
%e jours du moi sous la forme d'un entier (1-31); les digits simples sont précédés par un espace.
%F Le standard ISO pour le format de date (équivalent à écrire %Y-%m-%d).
%g Les deux derniers digits de l'année sous la forme d'nu entier (00-99)
%G L'année sous la forme d'un entier (ex. 1998).
%h nom local du mois en abrévié.
%H heure (24-heures) sous la forme d'un entier (00-23).
%I heure (12-heures) sous la forme d'un entier (01-12).
%j jours de l'année sous la forme d'un entier (001-366).
%m mois sous la forme d'un entier (01-12).
%M mois sous la forme d'un entierr (00-59).
%n nouvelle ligne.
%p heure localede l'équivalent AM ou PM.
%r temps sous la forme du système 12-heures (01-12) utilisant la notation AM/PM dans le format HH:MM:SS (AM|PM).
%R notation 24-heures ; %H:%M.
%S secondes sous la forme d'un entier (00-59).
%t caractère tabulation.
%T système 24-heures dans le format HH:MM:SS.
%u jours de la semaine sous la forme d'un entier (1-7), ou lundi est preprésenté par 1.
%U Semaine de l'année sous la forme d'un entier (00-52) ou dimanche est le premier jours de la semaine
%V Semaine de l'année sous la forme d'un entier (00-52) ou lundi est le premier jours de la semaine.La semaine contenant le 1er janvier 1 se trouve dans la nouvelle année si au plus 4 jours de cette semaine sont dans la nouvelle année.
%w jours de la semaine sous la forme d'un entier (0-6), ou 0 est dimanche.
%W numéro de la semaine dans l'année sous la forme d'un entier (00-52), où lundi est le premier jours de la semaine
%x représentation lcoale de la date.
%X représentation locale du temps
%y Année sans les centaines sous la forme d'un entier (00-99).
%Y Year with century, as a decimal number.
%z décalage depuis le fuseau UTC-0430 (4h 30 minutes de décalage vers l'ouest de Greenwich) ou aucun...
%Z nom du fuseau horaire, ou aucun caractère si le fuseau n'est pas précisé.
%% Caractère %.


La fonction renvoie 0 si le nombre de caractères exède la valeur de maxsize, et bien un entier indiquant le nombre de caractère copié dans s.
Il est à noter qu'en cas d'erreur la variable errno est définie.

Exemple:

         


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main( void )
{
    //valeur contenant le temps écoulé depuis
    //le 01/01/1970
    time_t time_of_day;

    //buffer contenant la chaine finale
    char buffer[ 150 ];

    //récuperer le temps passé
    time_of_day = time( NULL );

    //inscrire dans la chaine buffer notre string
   //telle que nous la voulons
    strftime( buffer, 150, "Aujourd'hui nous sommes le is %A %d %B , %Y",
           localtime( &time_of_day ) );

    //afficher la chaine
    printf( "%s\n", buffer );

    return 0;
}

        qui produit la sortie 


Aujourd'hui nous sommes le Thursday 10 December , 2001


Temps utilisé par le processeur

        C'est la fonctoin clock_t qui va nous permettre de traiter ce genre de cas. Celle-ci a pour prototype :
 


clock_t clock(void);

        Tout comme time_t, clock_t est un aurte nom pour unsigned long : 


#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif

        La routine clock renvoie le temps utilisé par le préprocesseur en microsecondes où le symbole CLOCK_PER_SEC représente le nombre d'unités par secondes : 


/* Clock ticks macro - ANSI version */

#define CLOCKS_PER_SEC  1000

        Ainsi en faisant deux appels à clock, l'un au départ d'un programme, et l'autre à la fin, on obtient par différence le temps utilisé par le programme. 


#include <stdio.h>
#include <time.h>
#include <stdlib.h>

/**
 * fonction contenant des boucles
 * inutiles faisant un traitement
 * inutile permettant de perdre du temps
 */
void compute( void )
{
    int i, j;
    double x;

    x = 0.0;
    //boucles inutiles
    for( i = 1; i <= 10000; i++ ) {
        for( j = 1; j <= 10000; j++ ) {
            x += i + j ;
        }
    }

    printf( "%16.7f\n", x );
}


int main( void )
{
    //temps au départ et à la fin
    clock_t start_time, end_time;

    //récuperer la date au départ
    start_time = clock();

    //faire un traitement
    compute();

    //récuperer le temps à la fin
    end_time = clock();

    //afficher la différence
    printf( "Le temps d'exécution est de %lu secondes\n",
          (long) ((end_time - start_time) / CLOCKS_PER_SEC) );

    return 0;
}

        Le programme ci-dessus donne la sortie : 


Lord Asriel : gcc temps.c  -o temps
Lord Asriel : temps
1000100000000.0000000
Le temps d'exécution est de 2 secondes
Lord Asriel :


[ Précédent | Index | Suivant ]


par Valentin BILLOTTE
vbillotte@programmationworld.com
http://www.programmationworld.com
Dernière mise à jour: