Accueil > Dossiers > C++

Indications pour ceux qui veulent lire vite...

Les titres principaux des parties sont centrés en gras et soulignées. Les sous parties sont alignées dans la gauche, en gras-italique et marron. Les récapitulatifs sont en bleu. Les codes C++ sont écrit en type "codé" et gras.

Tour d'horizon de la gestion du temps

Lorsque j'ai cherché comment utiliser le temps en C++ dans la bibliothèque MSDN, sur le site de Microsoft, j'ai trouvé une documentation assez lourde et en C. Je vous livre donc ici l'essentiel, légèrement adapté pour C++. Au programme : les fuseaux horaires, l'heure mondiale, l'heure locale...

---

SOMMAIRE DE LA GESTION DU TEMPS
1.1 L'heure et la date de votre ordinateur
1.2 L'UTC
1.3 Utilisation de la bibliothèque timeb.h
1.4 Fuseau horaire
1.5 Comment créer un chronomètre rudimentaire
1.6 Comment créer un agenda rudimentaire

---

1.1 L'heure et la date de votre ordinateur >> vers le sommaire

Pour commencer, démarrez Visual C++ 6 et créez un nouveau projet de type Win32 Console Application, demandez à ce qu'il soit vide ("An empty project"), ajoutez-y un fichier .cpp du nom que vous voulez, puis tapez les codes suivants :

Maintenant, nous allons ajouter les deux bibliothèques de temps dont nous avons besoin, à savoir time.h et timeb.h, comme ci-dessous :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
}

Lorsque nous demandons les informations sur le temps à l'ordinateur, il faut stocker sa réponse dans une chaîne de caractère. A cet effet, on déclare une sorte de buffer nommé tmpbuf, de la manière suivante :

#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
char tmpbuf[128];
}

Pour demander l'heure, on utilise la fonction _strtime, et on stocke la réponse dans le buffer :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
char tmpbuf[128];
_strtime( tmpbuf );
}

Il ne reste plus qu'à afficher classiquement le contenu du buffer :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
char tmpbuf[128];
_strtime( tmpbuf );
cout << "L'heure de cet ordinateur est : " << tmpbuf << "\n";
}

On demande ensuite à afficher la date. Pour cela, on procède de la même manière en utilisant la fonction _strdate, on stocke le résultat dans le buffer puis on l'affiche :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
char tmpbuf[128];
_strtime( tmpbuf );
cout << "L'heure de cet ordinateur est : " << tmpbuf << "\n";
_strdate( tmpbuf );
cout << "La date de cet ordinateur est : " << tmpbuf << "\n";
}

Voici le résultat final :

Récapitulatif pour l'heure et la date de l'ordinateur :
- Inclure les bibliothèques de temps :
#include <time.h>
#include <sys/timeb.h>
- Créer un buffer pour le temps : char tmpbuf[128];
- Appeler la fonction pour la date ou l'heure et stocker le résultat dans le buffer. Pour la date : _strdate( tmpbuf ); et pour l'heure : _strtime( tmpbuf );
- Pour afficher le résultat, il suffit d'afficher le contenu du buffer : cout << tmpbuf;

1.2 L'UTC >> vers le sommaire

L'UTC est le Coordinated Universal Time, l'équivalent de notre GMT. Par exemple, par rapport à l'UTC, nous avons une heure de décalage. Videz votre fichier de code pour qu'il soit comme au début, à savoir :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
}

Maintenant, nous allons déclarer la variable ltime, qui peut contenir un moment de référence dans le temps :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
time_t ltime;
}

L'UTC calcule à partir du moment de référence. Pour initialiser le moment de référence, on utilise la fonction time(). Si on affiche alors la variable ltime, on obtient la valeur qui nous sépare du moment de référence dans le temps, en secondes. Voici le code :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
time_t ltime;
time( &ltime );
cout << "Temps en secondes depuis le moment de reference : " << ltime << "\n";
}

La variable ayant été initialisée, on peut alors afficher l'heure et la date, à la manière unix par exemple :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
time_t ltime;
time( &ltime );
cout << "Temps en secondes depuis le moment de reference : " << ltime << "\n";
cout << "Date et heure a la maniere UNIX : " << ctime(&ltime) << "\n";
}

Une autre possibilité est d'afficher l'heure mondiale. Pour cela, on va créer une structure puis on utilisera successivement deux fonctions ; tout d'abord, la fonction gmtime() sur ltime :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
time_t ltime;
struct tm *gmt; // création de la structure
time( &ltime );
cout << "Temps en secondes depuis le moment de reference : " << ltime << "\n";
cout << "Date et heure a la maniere UNIX : " << ctime(&ltime) << "\n";
gmt = gmtime( &ltime ); // utilisation de la première fonction
}

Ensuite, en utilisant la fonction asctime() :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
time_t ltime;
struct tm *gmt; // création de la structure
time( &ltime );
cout << "Temps en secondes depuis le moment de reference : " << ltime << "\n";
cout << "Date et heure a la maniere UNIX : " << ctime(&ltime) << "\n";
gmt = gmtime( &ltime ); // utilisation de la première fonction
cout << "Coordinated Universal Time : " << asctime(gmt) << "\n";
}

Voici le résultat final :

Récapitulatif pour l'UTC :
- L'UTC est l'équivalent de notre GMT. Pour calculer notre heure et date, il se sert d'un moment de référence. Pour stocker ce moment, une déclare une variable qu'on va ensuite initialiser par une fonction :
time_t ltime;
time( &ltime );
- Si on affiche alors le contenu de la variable, on obtient le nombre de secondes qui nous sépare de ce moment de référence : cout << "Ecart depuis moment de references (secs) : " << ltime << "\n";
- On peut afficher l'heure à la manière UNIX : cout << "Facon unix : " << ctime(&ltime) << "\n";
- Il est possible d'afficher l'heure mondiale. Pour cela, il faut d'abord créer une structure :
struct tm *gmt;
Après, on applique deux fonctions :
gmt = gmtime( &ltime ); // utilisation de la première fonction
cout << "Heure GMT : " << asctime(gmt) << "\n";

1.3 Utilisation de la bibliothèque timeb.h >> vers le sommaire

Videz à nouveau votre fichier de code pour qu'il soit comme ci-dessous :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
}

Nous allons maintenant faire appel à la seconde bibliothèque, <timeb.h> pour créer une structure qu'on initialise avec la fonction _ftime() :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
struct _timeb tstruct;
_ftime( &tstruct );
}

Cette structure peut permettre d'utiliser plusieurs fonctionnalités. La première est une plus grande précision de l'heure en vous donnant les millisecondes :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
struct _timeb tstruct;
_ftime( &tstruct );
cout << "Millisecondes a ajouter a l'heure : " << tstruct.millitm << "\n";
}

On peut aussi obtenir la différence par rapport à l'heure GMT :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
struct _timeb tstruct;
_ftime( &tstruct );
cout << "Millisecondes a ajouter a l'heure : " << tstruct.millitm << "\n";
cout << "Difference par rapport a l'UTC : " << tstruct.timezone << "\n";
}

Voici ce qu'on obtient :

Récapitulatif pour l'utilisation de la biliothèque timeb.h :
- Tout d'abord, on crée une structure qu'on va initialiser à l'aide d'une fonction :
struct _timeb tstruct; //création de la structure
_ftime( &tstruct ); //initialisation en utilisant la fonction _ftime()
- Cette structure a plusieurs fonctionnalités. Elle peut donner les millisecondes :
cout << "Millisecondes a ajouter a l'heure : " << tstruct.millitm << "\n";
Elle peut aussi calculer la différence par rapport à l'heure mondiale GMT (UTC) :
cout << "Difference par rapport a l'UTC : " << tstruct.timezone << "\n";

1.4 Fuseau horaire >> vers le sommaire

Vidons encore le fichier de code afin qu'il soit comme ci-dessous :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
}

En utilisant la bibliothèque timeb.h étudiée précédemment, nous pouvons afficher très simplement le fuseau horaire de l'ordinateur :
#include <time.h>
#include <sys/timeb.h>
#include <iostream.h>

main()
{
struct _timeb tstruct;
_ftime( &tstruct );
cout << "Fuseau horaire de l'ordinateur : " << _tzname[0] << "\n";
}

Le résultat est le suivant :

Récapitulatif sur le fuseau horaire :
- Pour l'obtenir, il faut utiliser la bibliothèque timeb.h, c'est-à-dire créer la structure et l'initialiser par _ftime(). Après, on peut afficher le fuseau horaire : cout << "Fuseau horaire : " << _tzname[0] << "\n";

1.5 Comment créer un chronomètre rudimentaire >> vers le sommaire

Voici un schéma simple :

On va se servir du moment de référence. On sait qu'avec la fonction time() on prend la distance qui nous sépare du moment de référence, en seconde. Ainsi, il suffit de prendre cette distance au démarrage du chrono puis à l'arrêt du chono, et de faire la différence pour connaître le temps écoulé. Voici le code de l'application, basé sur le fonctionnement de time() décrit avec 1.2 L'UTC :

Et un exemple de résultat à l'éxécution :

1.6 Comment créer un agenda rudimentaire >> vers le sommaire

A partir de ce que vous avez appris sur la gestion du temps, voici une méthode assez brutale pour créer un agenda sur un après-midi (pour plus, il suffit d'étendre un peu le principe) :

Avec la fonction _strtime() (étudié dans 1.1 L'heure et la date de votre ordinateur) on a l'heure de l'ordinateur dans une chaîne de caractère. On demande à l'utilisateur d'associer 4 fonctions à 4 heures, pour se donner une sorte de rendez-vous. Ensuite, on passe l'heure de l'ordinateur dans une variable de type int, avec un système un tout petit peu complexe :
- Dans le buffer du temps, l'heure est écrite case par case. C'est-à-dire que si l'ordinateur affiche 16:32, le 1 correspond à tmpbuf[0] et le 6 à tmpbuf[1]. On fait donc deux variables de type int, chacune égale à une case : la première variable contient tmpbuf[0] et la seconde tmpbuf[1].
- Le problème, quand on passe d'une chaîne de caractère à une variable, c'est que cette dernière récupère la valeur décimale de la chaîne (voir tutorial 5, 1.1 Variables de caractères). On sait que le caractère 0 a comme valeur décimale 48, et ainsi lorsqu'on fait la saisie on soustrait 48 pour obtenir le chiffre réel de l'heure.
- Le premier chiffre saisi correspond aux dizaines et le second aux unités normales. Ainsi, lorsqu'on réassemble l'heure, on multiplit le premier par 10 et on y additionne le deuxième.

On fait ensuite la différence entre l'heure du rendez-vous et l'heure actuelle :
- Si cette différence est positive, cela veut dire que le rendez-vous va se produire. On cherche à déterminer dans combien de temps.
- On regarde alors si la différence est égale à 1. Dans ce cas là, le rendez-vous sera dans moins d'une heure : on signale donc qu'il faut se préparer.
- Si la différence n'est pas positive, alors le rendez-vous s'est déjà passé.

Ce programme vous donne surtout l'idée. Vous pourriez le gérer pour le mois avec un système de fichiers qui enregistrent pour le jour et l'heure exacte le rendez-vous, ce qui ferait un système plus correct d'agenda. Voici un exemple de l'éxécution à 16h42 :