FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 175, dernière mise à jour : 17 décembre 2010  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de www.developpez.com et de l'expérience personnelle des auteurs.

Je tiens à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.


SommaireDivers bisGestion des dates et heures (10)
précédent sommaire suivant
 

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.

Mis à jour le 2 mars 2003 Bob Melem

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.

Mis à jour le 2 mars 2003 Bob Melem

La fonction time permet d'obtenir la date et l'heure courante (heure système).

Code C :
1
2
3
#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 :

Code C :
1
2
3
4
5
#include <time.h> 
  
time_t t; 
  
time(&t); /* t contient maintenant la date et l'heure courante */

Mis à jour le 31 janvier 2003 LFE

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 :

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
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 :

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  
#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(×tamp); 
  
    /* 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.

Mis à jour le 20 septembre 2004 gl haypo

La fonction strftime permet de formater une date en appliquant le même principe de chaîne de formatage que sprintf.

Code C :
1
2
3
#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 formaté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 :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
+------+-------------------------------------------------------------+ 
| 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 quatre chiffres                                  | 
|  %Z  | Nom du fuseau horaire                                       | 
|  %%  | Le caractère %                                              | 
+------+-------------------------------------------------------------+
Voici un exemple pour illustrer cela :

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
#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; 
}

Mis à jour le 2 mars 2003 gege2061 LFE

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.

Code C :
1
2
3
4
5
6
7
8
9
10
11
#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 à :

Code C :
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h> 
#include <time.h> 
  
int main(void) 
{ 
    time_t t = time(NULL); 
  
    printf("%s\n", asctime(localtime(&t))); 
  
    return 0; 
}

Mis à jour le 31 janvier 2003 LFE Melem

La fonction difftime() permet de soustraire deux dates. Ces dernières doivent être sous la forme d'une structure 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 :

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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; 
}

Mis à jour le 7 novembre 2005 gege2061

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 grâce à la fonction GetSystemTime().

Code c :
void GetSystemTime(SYSTEMTIME *lpSystemTime);

Mis à jour le 2 mars 2003 Bob

Comment connaître l'heure locale (Windows) ?

En utilisant GetLocalTime() au lieu de GetSystemTime(). Le programme suivant affiche la date et l'heure locales en utilisant cette fonction.

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#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; 
}

Mis à jour le 2 mars 2003 Bob

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.

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#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();                                    /* Arrêt 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'exécution 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.

Code C :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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);                                        /* Arrêt 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; 
}

Mis à jour le 11 septembre 2006 Emmanuel Delahaye gl

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2014 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
 
 
 
Partenaires

PlanetHoster
Ikoula