time.h et ses fonctions

Introduction du cours

Bonjour à tous !

Vous venez de terminer la lecture des deux premiers chapitres du cours officiel sur le C ? Mais vous avez peut-être remarqué que la gestion du temps manque à l'appel.

Effectivement, la gestion du temps (que ce soit créer une attente ou afficher la date) ne fait pas partie du tutoriel officiel du C de M@teo21. Et c'est ce que je vais vous apprendre tout au long de ce cours.

La gestion du temps en C/C++ passe par la bibliothèque time.h, renommée en ctime en C++. Donc pour suivre le cours, vous devrez utiliser la directive de préprocesseur correspondant au langage dans lequel vous compilez :

#include <time.h> #include <ctime>

Grâce à cette directive de préprocesseur, vous serez apte à utiliser l'intégralité des fonctions présentes dans la bibliothèque time.h.

Bonne lecture !

Un nouveau standard C++ est sorti il y a peu, nommé C++ 0x.
Il introduit une nouvelle façon de gérer le temps via la classe « chrono ».
Lorsque la norme C++ 0x sera rendue plus facile d'accès, je rédigerai peut-être un cours dessus.

Obtenir une date et une heure

Dans cette partie nous allons voir :

• comment obtenir la date et l'heure actuelle ;

• comment situer son programme dans le temps (et ainsi créer un chronomètre, par exemple).

struct tm : Structure du temps

Pour manipuler les dates et les heures, il nous faut de quoi stocker le temps de manière compréhensible, c'est-à-dire qu'au lieu d'une seule variable contenant des secondes (on se retrouverait avec des modulos partout), nous aurons une structure contenant un instant mais utilisant les différentes unités et informations que l'on emploie (année, mois, jour du mois, jour de la semaine, jour de l'année, heure, minute, seconde et si nous sommes en heure d'été ou d'hiver).

struct tm répond à ce besoin. Il s'agit d'une structure contenant les variables suivantes.

Variable

Représente

Rang

tm_year

Le nombre d'années depuis 1900.

0 - ?

tm_mon

Mois écoulés depuis janvier (n° du mois-1).

0 - 11

tm_yday

Nombre de jours écoulés depuis le 1er janvier (n° jour-1).

0 - 365

tm_mday

Numéro du jour du mois.

1 - 31

tm_wday

Nombre de jours écoulés depuis dimanche (et non lundi).

0 - 6

tm_hour

Nombre d'heures écoulées depuis minuit.

0 - 23

tm_min

Nombre de minutes écoulées depuis le dernier changement d'heure.

0 - 59

tm_sec

Nombre de secondes écoulées depuis le dernier changement de minute.

0 - 60*

tm_isdst

-1 si l'information est indisponible ;
0 si c'est l'heure d'hiver ;
+1 si c'est l'heure d'été.

-

? : Dépend de la façon dont la date est gérée par votre système d'exploitation.
* : Certains systèmes nécessitent une marge pour éviter des bugs. Néanmoins, retenez 0 - 59. Cette marge n'a pas vraiment d'importance.

Cette structure correspond donc à la représentation d'un instant avec de nombreuses informations simples à exploiter ! Nous n'allons pas encore la remplir automatiquement suivant l'heure interne de votre ordinateur, mais je vous propose un code d'exemple pour comprendre son utilisation (pas très propre mais c'est pour l'exemple).

Exemple#include <stdio.h> #include <time.h> int main(void) { struct tm instant; int remplir; printf("Entrez le mois : "); scanf("%d", &remplir); instant.tm_mon = remplir-1; printf("Entrez le jour : "); scanf("%d", &remplir); instant.tm_mday = remplir-1; printf("Entrez l'heure : "); scanf("%d", &remplir); instant.tm_hour = remplir; printf("Entrez la minute : "); scanf("%d", &remplir); instant.tm_min = remplir; printf("Entrez la seconde : "); scanf("%d", &remplir); instant.tm_sec = remplir; printf("%d/%d ; %d:%d:%d", instant.tm_mday+1, instant.tm_mon+1, instant.tm_hour, instant.tm_min, instant.tm_sec); return 0; }

Pour les directives de préprocesseur, on inclut bien sûr stdio.h pour les fonctions printf() et scanf() et time.h pour notre struct tm. stdlib.h n'est pas nécessaire dans notre cas.

Dans la fonction int main(void) (void signifie que la fonction ne prend rien), on a la déclaration de la structure instant de type struct tm et la variable « remplir » qui nous servira à supprimer un décalage par la suite. Puis on demande à l'utilisateur d'entrer des valeurs qui seront conservées dans les variables appropriées en passant par « remplir ». Grâce à « remplir », on supprime le décalage présent pour le mois et le jour. Pour les heures, minutes et secondes, ce n'est pas la peine. Pour remplir la structure, on remplit chaque variable en la précédant du nom de la structure et d'un point. Les structures vous sont expliquées dans le cours officiel.

Au sein de la fonction printf(), on a une mise en forme des valeurs que l'on a remplies. Remarquez que les variables tm_mday et tm_mon ne sont pas affichées telles qu'elles sont mais avec une incrémentation afin d'obtenir les vrais numéros du mois et du jour. En fait, cela sert à remettre tout ça dans les bonnes valeurs. Ces problèmes de décalages peuvent être assez déroutants, mais on comprend très vite grâce au tableau situé au début de cette partie.

Voici ce que ça peut donner :

Entrez le mois : 11 Entrez le jour : 10 Entrez l'heure : 0 Entrez la minute : 0 Entrez la seconde : 0 10/11 ; 0:0:0

Il peut être intéressant d'utiliser un pointeur vers une struct tm plutôt qu'une struct tm directement car les fonctions de time.h renvoient des pointeurs et non la structure pointée. Pour le remplissage manuel que nous venons d'effectuer, cela reste assez déconseillé. Les pointeurs vous sont expliqués dans le cours officiel.

Exercice

Ajoutez les années à mon code. Attention, il y a un piège !

clock() : Situer son programme dans le temps

clock() est un bidule assez intéressant. Il permet de situer son programme dans le temps. Voici son prototype :

clock_t clock (void);

Cette fonction ne prend donc aucun paramètre et renvoie un nombre sous un nouveau type : le clock_t. Le type clock_t permet d'exprimer un nombre de clock ticks. Utilisez donc ce type lorsque vous souhaitez utiliser des clock ticks (comme le type size_t fait référence à une taille).

Le clock tick (ou battement pour les puristes du français) est une unité de mesure du temps interne de votre ordinateur. Qu'est-ce que ça représente par rapport à la seconde ? Eh bien…
Vous l'avez deviné : ça dépend !
En fait, cette valeur dépend de votre système d'exploitation et de votre processeur. time.h possède une macro permettant savoir combien de clock ticks par seconde votre ordinateur gère. Il s'agit de la macro CLOCKS_PER_SEC.

Il est possible que clock() retourne -1.
Si c'est le cas, c'est qu'il y a eu une erreur. Prévoyez ce cas dans vos futurs programmes.

Bon, assez parlé, testons clock().

#include <stdio.h> #include <time.h> int main(void) { printf("%f\n", (double) clock()); return 0; }

Ce code est un programme tout bête qui affiche la valeur retournée par clock(). Remarquez le (double) avant l'appel de la fonction. Il permet de transformer les clock_t renvoyés en double afin d'éviter un beau warning. On appelle cette action le cast (un cast en (int) marche, mais néanmoins il arrive que ce type contienne un nombre décimal, alors on utilise %f avec un cast(double), mais attention, ça ne marche pas dans tous les cas).

Qu'affiche-t-il ?

0

Aïe. Quelque chose ne va pas dans ton code.
Laisse-moi deviner. Comme clock() est appelée dès le début, elle renvoie le début du programme, soit 0 clock tick ?

Exactement ! Il va donc falloir mettre une attente avant l'appel de clock().

#include <stdio.h> #include <time.h> int main(void) { getchar(); printf("%f\n", (double) clock()); return 0; }

Un getchar() vous demandera d'appuyer sur la touche Entrée avant de continuer et d'afficher la valeur renvoyée par clock().

C'est bien beau, mais tu as dit que cette fonction était intéressante.
Or, ça ne sert à rien.

Bien au contraire ! Réfléchissez bien. Cela permet de faire un chronomètre par exemple ! Voyez cette nouvelle version du Plus ou Moins !

#include <stdio.h> #include <stdlib.h> #include <time.h> int main(void) { int mystere, nombreentre; clock_t temps; srand(time(NULL)); mystere=rand()%100+1; do{ puts("Quel est le nombre ? "); scanf("%d", &nombreentre); if(nombreentre>mystere) puts("C'est moins !\n"); if(nombreentre<mystere) puts("C'est plus !\n"); if(nombreentre==mystere){ temps=clock(); printf("Bravo !\nTu as mis %f secondes a trouver le nombre.\n", (double) temps/CLOCKS_PER_SEC); } }while(nombreentre!=mystere); return 0; }

C'est le même logiciel (je l'ai un peu simplifié mais c'est le même principe) sauf que l'on a ici une variable temps de type clock_t et lorsque le nombre est trouvé, on lui donne la bonne valeur via la fonction clock(). Après cela, on affiche les résultats grâce au fameux %f et une division temps/CLOCKS_PER_SEC sans oublier le cast (double) avant pour éviter un warning. Grâce à cette division, on obtient des secondes et non des clock ticks.

Quel est le nombre ? 61 Bravo ! Tu as mis 13.156000 secondes a trouver le nombre.Exercice

On peut faire un chronomètre, mais aussi une attente ! Créez une fonction permettant de faire une attente et qui aura ce prototype :

void attendre(float temps);

Le temps sera bien sûr en secondes (et pas en siècles…).

C'est parti !

Correction
Il fallait utiliser une boucle vide se répétant tant que clock() ne renvoie pas une valeur que l'on a prédite à l'avance via un petit calcul. J'ai réalisé, en plus de cette fonction, un petit programme pour tester.

#include <stdio.h> #include <time.h> void attendre(float temps); int main(void) { int compteur; for(compteur=10;compteur>0;compteur--){ printf("%d...\n", compteur); attendre(1); } puts("BONNE ANNEE !!!\n"); return 0; } void attendre(float temps) { clock_t arrivee=clock()+(temps*CLOCKS_PER_SEC); // On calcule le moment où l'attente devra s'arrêter while(clock()<arrivee); }

Pour calculer le moment où l'attente s'arrête, on prend le moment dans lequel on se trouve (le début de l'attente) puis on y ajoute le temps d'attente en le transformant en clock ticks (d'où la multiplication par CLOCKS_PER_SEC).

Par contre, cette attente n'est pas aussi géniale que l'on pourrait le croire. En effet, elle consomme beaucoup de CPU. Il existe deux fonctions plus propres et moins gourmandes pour faire une attente : sleep() et Sleep() (la majuscule fait toute la différence).

sleep() est dans le header unistd.h (Linux et Mac uniquement) et Sleep() dans windows.h (vous savez pour quel système d'exploitation !). De plus elles ne prennent pas la même unité : Sleep() attend des millisecondes d'après sa page sur la MSDN et sleep() des secondes. Voici donc un code préprocesseur vous permettant d'obtenir une fonction attendre propre et portable sous forme de macro :

#if defined (WIN32) || defined (WIN64) #include <windows.h> #define ATTENDRE(temps) Sleep(temps*1000) #else #include <unistd.h> #define...