Gestion tu temps, créez votre propre "library"
Propos par nabouill

le jeudi 28 janvier 2010 13h 44mn 40s

4195 visualisations

  Crez votre propre library pour grer le temps dans vos programmes.
Pour appeler une fonction interval rgulier, savoir combien de temps s'est coul depuis l'instant T, mettre le programme en pause pour allger un peu les ressource demander au CPU, rcuprer le temps coul pour faire un compteur ...   





Voici une petite classe que je ne cesse d'amliorer, trs simple mais trs pratique. je vais directement mettre le code et on va voir ensuite ce qu'on peu en faire.

Le code
Comment a marche ?
mettre a en DLL


Le code
Commenons par MyTimer.h :

Code c++ :



#ifndef __MyTimer_H__
#define __MyTimer_H__

#include <ctime> // for clock()
#include <windows.h> // for Sleep()


class  MyTimer
{
    public:
        MyTimer(int t_ms_interval);

        ///methodes
        bool isExceed();       //renvoie "true" si l'interval temps est depass
        int getInterval();     //renvoie l'interval definie
        int getTimeExceedMs(); // renvoie les temps pass en ms depuis la derniere mise a jour
        int getTimeExceedSc(); // renvoie les temps pass en seconde depuis la derniere mise a jour
        int getTimeUntilMS();  //renvoie le temps restant en milliseconde
        int getTimeUntilSc();  //renvoie le temps restant en seconde
        void reset();          //remise a zero du temps pass
        void setInterval(int t_ms_interval);  //redfini l'interval
        void waitUntilInterval();        //endort le programme jusqu'a ce que l'interval soit dpass
        void waitAll(int t_ms_interval); // endort le programme pendant le temps t_intrerval

    private:

        clock_t timeExceed; //enregistre le temps a l'instant T
        clock_t actualTime; //enregistre le temps a l'instant T
        int interval;       //gestion de l'interval Temps en millisecondes

};

#endif





Puis MyTimer.cpp

Code c++ :


#include "MyTimer.h"


// constructeur
MyTimer::MyTimer(int t_ms_interval)
{
    interval = t_ms_interval;
    actualTime = clock();
    timeExceed = clock();
}


    ///***********************************************************************

int MyTimer::getTimeExceedMs()
{
    actualTime = clock();
    int timeTempo = actualTime - timeExceed;
    return timeTempo;
}

    ///***********************************************************************

int MyTimer::getTimeExceedSc()
{
    actualTime = clock();
    int timeTempo = actualTime - timeExceed;
    int seconde = timeTempo / 1000;
    return seconde;
}

    ///***********************************************************************

int MyTimer::getTimeUntilMS()
{
    int timeTempo = interval - getTimeExceedMs();
    return timeTempo;
}

    ///***********************************************************************

int MyTimer::getTimeUntilSc()
{
    int seconde = (interval - getTimeExceedMs()) / 1000;
    return seconde;
}

    ///***********************************************************************


bool MyTimer::isExceed()
{
    actualTime = clock();
    if(actualTime - timeExceed > interval)
    {
        timeExceed = actualTime;
        return true;
    }
    else
    {
        return false;
    }
}

    ///***********************************************************************

void MyTimer::setInterval(int t_ms_interval)
{
    interval = t_ms_interval;
}

    ///***********************************************************************

int MyTimer::getInterval()
{
    return interval;
}

    ///***********************************************************************

void MyTimer::reset()
{
    actualTime = clock();
    timeExceed = clock();
}

    ///***********************************************************************

void MyTimer::waitUntilInterval()
{
    if(!isExceed())
    {
        Sleep(interval - getTimeExceedMs());
        actualTime = clock();
        timeExceed = clock();
    }
}

    ///***********************************************************************

void MyTimer::waitAll(int t_ms_interval)
{
    Sleep(t_ms_interval);
}






Comment a marche ?

Petit exemple:

Les trucs de base:

Code c++ :


MyTimer timer(1000);
timer.setInterval(5000); //change l'interval temps (en ms)

//executer un fonction que si l'interval temps et dpass
if(timer.isExceed())
{
      //je fais mon truc
}

//je veut crer un boucle qui dur le temp de mon interval
while(!timer.isExceed())
{
}

//je recupre mon interval
int intervalTemp = timer.getInterval();


Faire une pause, allger les ressources cpu:

Code c++ :

MyTimer timer(1000);

//je mais mon programme en pause seulement le temps restant de mon interval
timer.waitUntilInterval();

//je met mon programme en pause le temps que je veux, sans modifier l'interval de timer
timer.waitAll(10000);

//je reset mon timer , c'est a dire que je remet le temps actuel  et le temps pass a l'instant T
timer.reset();


Chronmtre / compte rebour:

Code c++ :

MyTimer timer(10000); //un interval de 10 secondes

//**** exemple chronomtre

while(1)
{
     cout << timer.getTimeExceedMs() << endl; //affiche le temps ecoul depuis le dbut du timer (en ms)
     cout << timer.getTimeExceedSc() << endl; //affiche le temps ecoul depuis le dbut du timer (en seconde)
       /*je me permet de prciser que cette mthode ne reset jamais le timer,
          donc peut importe son interval dfini il continuera indfiniment*/

}

//**** exemple compte a rebours

while(1)
{
     cout << timer.getTimeUntilMs() << endl; //affiche le temps restant avant la fin du timer (en ms)
     cout << timer.getTimeUntilSc() << endl; //affiche le temps restant avant la fin du timer (en seconde)
      /* l encore, le timer ne sera jamais rinitialiser, donc attention si vous ne souhaiter pas rentrer dans les valeurs ngative
          la mise en place d'un   if(timer.isExceed()) peut s'avrer utile pour arrter pile a 0 */

}




mettre a en DLL


Pour une utilisation frquente dans vos programmes, je vous propose de crer un lib pour facilit sont intgration.

Avec Code::Blocks crez un projet "Dynamic Link Library", supprimez les fichiers cre automatiquement.
Puis crer les 2 fichiers "MyTimer.cpp" et "MyTimer.h" (ou appelez les comme vous voulez)
Compilez. Et vous obtenez une belle DLL (de 6,5 ko)  et un fichier .a smile

Et pour ceux qui n'aurait pas code::blocks (o les fainant ... si si je sait qu'il y en a wink )
je vous laisse les tlcharger sur ce lien:
fichier.dll+fichier.a+fichier.h


Semblerait-il que pour faire fonctionner ce code sous linux, il faut remplacer #include <windows.h> par #include <unistd.h>.
Perso, je n'ai pas essay, mais si quelqu'un peut me le confirmer...

#1 

28-01-2010 16:01:19

nico
Webmaster
Date d'inscription: 07-08-2009
Messages: 563
Corrections: 9

Merci nabouill, cette classe l'air pratique.
Je m'interroge juste sur <ctime>, je sais plus trop o sur le net, j'ai rcupr une classe exemple qui utilise la frquence de l'horloge pour chronomtrer, Donc je voulais savoir si il y a des diffrences au niveau de la prcision ? tlcharger exemple 64 bit

Hors ligne


#2 

28-01-2010 17:13:45

TUpac
Habitu
Date d'inscription: 08-09-2009
Messages: 387
Corrections: 1

Beau boulot nabouille mais on trouve l'quivalence sous irrlicht je crois non ?


"Si vous ne partagez pas votre stabilité avec les pauvres, les pauvres partageront leur instabilité avec vous."

Hors ligne


#3 

29-01-2010 22:27:27

nabouill
Abonn
Date d'inscription: 17-09-2009
Messages: 242
Corrections: 1

Merci vous.

nico a crit:

Je m'interroge juste sur <ctime>

Effectivement, ce serait un peut l'quivalent de time.h plus rvolue et rserv au C++ d'aprs ce que j'ai trouv (ne pas confondre avec le fichier time.h sur ton lien)
mais je ne saurait te dire si il est plus prcis ou non.

TUpac a crit:

mais on trouve l'quivalence sous irrlicht je crois non ?

J'ai bien vue une sorte de gestion de temps dans Irrlicht oui mais je ne l'ai pas bien saisie, du moins ce que j'en ai compris ne me paraissait pas trs pratique (a vient peut-tre de moi aussi)
du coup a force de me crer des petite fonction un peu partout dans chaque projet et faire des copier coller a chaque coup, j'ai penser de crer une petite lib pour grer a deviendrais plus pratique.

En attendant, si vous avez des ide d'amlioration... faite signe


mes sites: www.manga-vf.fr et www.series-vf.fr

Hors ligne


#4 

30-01-2010 02:48:31

nico
Webmaster
Date d'inscription: 07-08-2009
Messages: 563
Corrections: 9

coucou, comme amlioration je verrai bien une suppression des fonctions qui retournent le temps en seconde,
je trouve que a alourdi la classe et qu'il serait prfrable d'adopt une solution plus succinte.
tu pourrait aussi passer par une liste d'initialisation pour les objets afin de rduire encore le code, puis supprimer la fonction de destruction de l'objet qui est vide, pour encore grappiller de la place. cela dit c'est vraiment du chipotage hein wink
et une version franaise en option tongue

edit: j'ai bloqu sur le terme "wait", a me parait bizarre avec l'utilisation de sleep(), qu'en pensez-vous ?

Hors ligne


#5 

31-01-2010 22:15:08

nabouill
Abonn
Date d'inscription: 17-09-2009
Messages: 242
Corrections: 1

nico a crit:

je verrai bien une suppression des fonctions qui retournent le temps en seconde,

Oui, c'est vrai que j'ai hsiter un peu a la mettre celle l, mais l'ide tait que ce serait plus simple pour intgrer un chrono dans un programme, car sinon on devrait rcupre le temps en ms puis faire le calcule pour afficher le temps en seconde, ce qui du coup alourdirais le code du programme. En somme l'un o l'autre.. c'est vrai que a porte rflexion. (mais perso, je prfre allger mes programmes, ce qui n'engage que moi bien sr).

nico a crit:

tu pourrait aussi passer par une liste d'initialisation pour les objets afin de rduire encore le code

C'est vrai, je les crit comme par habitude, car j'ai toujours trouv plus facile lire. Mais a pourrait bien faire l'objet d'une modification, effectivement.

nico a crit:

puis supprimer la fonction de destruction de l'objet qui est vide

L encore, rien ne t'echappe tongue, mais tu as raison , a aussi sa fait partie de mon protocole de codage, je ne peut pas m'en empcher (faudrait que je revois mes vieilles habitudes) OK je l'enlve.

nico a crit:

cela dit c'est vraiment du chipotage hein

Oui, si on veut, mais toutes remarque est bonne prendre et mrite rflexion.

nico a crit:

j'ai bloqu sur le terme "wait", a me parait bizarre avec l'utilisation de sleep(), qu'en pensez-vous ?

Tout a fait d'accord, j'ai chercher un terme que a, mais mon imagination n'as pas trouv, mais je voudrais un autre truc que Sleep(), qui des driv  est dj intgrer dans bien des classe (nanoSleep, uSleep...) Si quelqu'un une ide, je suis preneur.

Dernire modification par nabouill (31-01-2010 22:18:55)


mes sites: www.manga-vf.fr et www.series-vf.fr

Hors ligne


#6 

03-02-2010 08:01:19

nico
Webmaster
Date d'inscription: 07-08-2009
Messages: 563
Corrections: 9

salut, j'ai vir mon prcdant post qui racontait n'importe quoi wink et je vous propose un nouvel essai critiquer.

Code c++ :

#ifndef CTIMER_LOADED
#define CTIMER_LOADED

#include <ctime> // pour clock()
#include <windows.h> // pour Sleep()

#define tempsActuel  clock()
enum Temps {Ms = 1, Sc = 1000};

class  CTimer
{
    public:
        CTimer(int Interval);

        void pausePendantInterval();        //endort le programme jusqu'a ce que l'interval soit dpass
        void pauseDurant(int Interval)const; // endort le programme pendant le temps t_intrerval
        void raz();          //remise a zero du temps pass

        bool delaiEcoule();       //renvoie "true" si l'interval temps est depass
        int recupTempsEcoule(Temps Format=Ms)const; // renvoie les temps pass en ms depuis la derniere mise a jour
        int recupTempsRestant(Temps Format=Ms)const;  //renvoie le temps restant en seconde

        int interval;       //gestion de l'interval Temps en millisecondes

    private:
        clock_t tempsDeDepart; //enregistre le temps a l'instant T
       
};
#endif



Code c++ :

using namespace std;

CTimer::CTimer(int Interval)
{
    interval = Interval;
    tempsDeDepart = tempsActuel;
}

///***********************************************************************

int CTimer::recupTempsEcoule(Temps Format)const
{
    return (tempsActuel - tempsDeDepart)/Format ;
}

///***********************************************************************

int CTimer::recupTempsRestant(Temps Format)const
{
    return (interval - recupTempsEcoule())/Format ;
}

///***********************************************************************

bool CTimer::delaiEcoule()
{
    if(tempsActuel - tempsDeDepart > interval)
    {
        tempsDeDepart = tempsActuel;
        return true;
    }
    else return false;
}

///***********************************************************************

void CTimer::raz()
{
    tempsDeDepart = tempsActuel;
}

///***********************************************************************

void CTimer::pausePendantInterval()
{
    if(!delaiEcoule())
    {
        Sleep(interval - recupTempsEcoule());
        tempsDeDepart = tempsActuel;
    }
}

///***********************************************************************

void CTimer::pauseDurant(int Interval)const
{
    Sleep(interval);
}



Code c++ :

#include <iostream>

int main()
{
    CTimer monTimer(5000); //un interval de 5 secondes

    while(!monTimer.delaiEcoule())
        cout << "exemple chronomtre : " << monTimer.recupTempsEcoule() << endl;

    monTimer.interval=5000;

    while(!monTimer.delaiEcoule())
        cout << "exemple compte a rebours : " << monTimer.recupTempsRestant() << endl;

    return 0;
}

Hors ligne


#7 

04-02-2010 23:35:27

nabouill
Abonn
Date d'inscription: 17-09-2009
Messages: 242
Corrections: 1

nico a crit:

j'ai vir mon prcdant post qui racontait n'importe quoi

Non y avait du bon aussi, mais j'avais pas encore eu le temps de l'tudier a fond. Sinon:

1_
Dans l'ensemble, je trouve a vraiment mieux a part un point extrmement important :

Code c++ :


     public:
        CTimer(int Interval);
        //.......
        int interval;       //QU'EST-CE QUE TU FAIT LA TOI COCO ! TU SORT TOUT DE SUITE ET TU RETOURNE DANS private !!!!!

     private:
        clock_t tempsDeDepart;



Mme si je sais que tu va me dire "oui mais a vite de crer des ascenseurs, ce qui allge pas mal notre code" roll
C'est vrai, mais ceci est INTERDIT yikes . (j'exagre un peu hein)

2_
Sinon le

Code c++ :

#define tempsActuel  clock()

est vraiment trs bon

3_
Ta traduction franaise passe plutt pas mal, c'est vrai que le terme "pause" passe bien mieu que "wait"wink si tu me permet de chipoter un peut :
Je remplacerais bien "bool delaiEcoule()" par "bool delaiEstEcoule()"
et "void pausePendantInterval()" par "void pauseJusquaInterval()"
je trouve a plus parlant.

4_
Dernier point (mais l a viens de mes connaissance) je ne comprend pas bien comment marche:

Code c++ :

enum Temps {Ms = 1, Sc = 1000};
//.............
int recupTempsEcoule(Temps Format=Ms)const;


je ne vois pas comment on fait pour rcuprer le temps en seconde ou en milliseconde ( la demande), tu aurais un exemple STP ?

En tout cas beau travail.


mes sites: www.manga-vf.fr et www.series-vf.fr

Hors ligne


#8 

05-02-2010 03:04:59

nico
Webmaster
Date d'inscription: 07-08-2009
Messages: 563
Corrections: 9

Coucou, sympa la critique, dommage qu'il n'y ai pas plus de monde sad , mais en tout cas je trouve que c'est trs enrichissant de faire des codes ensemble. on devrait en faire plus souvent wink

Code c++ :


     public:
        CTimer(int Interval);
        //.......
        int interval;       //QU'EST-CE QUE TU FAIT LA TOI COCO ! TU SORT TOUT DE SUITE ET TU RETOURNE DANS private !!!!!

     private:
        clock_t tempsDeDepart;


Alors concernant la variable que j'ai mit en public, en fait je n'ai pas compris pour quelle raison il faut la privatis, puisque il y une fonction pour la modifier et une autre pour la lire, donc est-ce que a ne revient pas au-mme ? pourtant tu as raison que c'est une rgle de base, mais j'avoue ne pas comprendre les problmes que a peut engendrer ?

nabouill a crit:

Sinon le

Code c++ :


#define tempsActuel  clock()


est vraiment trs bon

Oui, d'ailleur on pourrai l'utiliser pour sleep aussi, ce qui donnerai un truc du genre: #define pause(millisecondes)  sleep((millisecondes))

nabouill a crit:

Ta traduction franaise passe plutt pas mal, c'est vrai que le terme "pause" passe bien mieu que "wait" si tu me permet de chipoter un peut :
Je remplacerais bien "bool delaiEcoule()" par "bool delaiEstEcoule()"
et "void pausePendantInterval()" par "void pauseJusquaInterval()"

ouai, je me suis tonn moi mme smile, la plupart du temps quand j'cris en franais c'est moins comprhensible qu'en anglais sad , il faut dire que c'est pas evident avec les accents interdit et companies........
j'adre au "delaiEstEcoule", par contre je ne suis pas d'accord sur  "jusqu'a Intervalle"(je viens d'apprendre comment a s'crit wink ), d'prs ce que j'ai pu comprendre, un intervalle reprsente une gamme vec une valeur basse et une valeur haute, donc quand tu dis jusqu'a "intervalle" pour moi a voudrait dire: j'usqu'a ce qu'on rentre dans l'intervalle, enfin a dpend comment on l'interprete, je pense que tu voulais dire "jusqu'a sortie de l'intervalle" ?

nabouill a crit:

Dernier point (mais l a viens de mes connaissance) je ne comprend pas bien comment marche:

Code c++ :

enum Temps {Ms = 1, Sc = 1000};
//.............
int recupTempsEcoule(Temps Format=Ms)const;

alors je vais essayer de t'expliquer ce que j'ai compris, mais le problme c'est que j'ai pas tout compris lol puisque normalement l'enumeration devrait tre l'interieur de la classe, mais je n'ai pas reussi l'utiliser de cette faon donc je l'ai dclar avant. enfin bref....
La fonction "recupTempsEcoule(Temps Format);", prend comme parametre la variable Format.
cette variable peut prendre uniquement les valeurs "1" et "1000", puisqu'elle est du type "Temps" (*)
Ensuite dans la declaration de la fonction, tu peut voir "=Ms", ce qui signifie que la valeur par defaut gal la valeur de "Ms" soit "1"
voici comment a s'utilise:
ex: recupTempsEcoule(Sc); l'ordi va traduire-> recupTempsEcoule(1000);
ex: recupTempsEcoule(Ms); l'ordi va traduire-> recupTempsEcoule(1);
ex: recupTempsEcoule(); l'ordi va traduire-> recupTempsEcoule(1) puisque on a declar "Ms" comme valeur par defaut.

Dit moi si tu veut que j'explique plus en detail smile mme si j'ai moi mme besoins de plus d'info ce sujet wink


(*) c'est pour a que j'ai virer mon premier code avec les define, puisque on pouvait se retrouver avec des divisions par zero hmm , alors qu'avec les enumerations c'est ultra plus scuris wink

Hors ligne


#9 

13-02-2010 21:54:33

nabouill
Abonn
Date d'inscription: 17-09-2009
Messages: 242
Corrections: 1

nico a crit:

sympa la critique, dommage qu'il n'y ai pas plus de monde  , mais en tout cas je trouve que c'est trs enrichissant de faire des codes ensemble. on devrait en faire plus souvent

Tout a fait d'accord, dommage qu'il ni ais pas plus de monde. La progression s'accroit nettement plus vite a plusieurs.

nico a crit:

Alors concernant la variable que j'ai mit en public, en fait je n'ai pas compris pour quelle raison il faut la privatis, puisque il y une fonction pour la modifier et une autre pour la lire, donc est-ce que a ne revient pas au-mme ? pourtant tu as raison que c'est une rgle de base, mais j'avoue ne pas comprendre les problmes que a peut engendrer ?

Le problme que a peut engendrer dans notre cas n'est pas bien mchant, le problme s'agrandit vite si l'on a plusieurs attribues, dont certaine qui sert a calculer certaine chose dans des mthode, des attribues que l'on utilise nul par dans notre code sauf pour faire des vrifications. Si ces attribues sont modifiable de l'extrieur, elle peuvent vite fausser toutes notre classe. Un utilisateur cre un pointeur sur cette attribue qui l'envoie a des mthodes et des mthodes d'autre classe... et tout peut vite devenir n'importe quoi. C'est pour a qu'il faut les privatiser, c'est une SECURITE, et plutt que dire "celle l je la privatise, pas celle l a va tre plus simple..." Il est prfrable de toutes les privatis directement car le simple ajout d'une mthode par la suite peut vite faire changer d'avis.

nico a crit:

je pense que tu voulais dire "jusqu' sortie de l'intervalle" ?

Non enfaite je voulais dire "jusqu' la fin de l'interval" pour etre exact (ce qui aurait pus donn "pauseJusquaFinInteval" mais je l'avais raccourcie un peut) c'est que signification de "interval" semble bonne, du coup ton "pausePendantInterval()" est sans doute un meilleur terme mme si je pense que l'on peut trouver mieu. Si quelqu'un a une ide...

nico a crit:

alors je vais essayer de t'expliquer ce que j'ai compris

Merci, je pense avoir bien compris ce que tu m'as expliqu smile


Bon, du coup je regarde a, et je remet tout au propreds que j'ai un peu de temps, e, attendant, si il y a d'autre ide, faite signe

Dernire modification par nabouill (13-02-2010 21:55:55)


mes sites: www.manga-vf.fr et www.series-vf.fr

Hors ligne


#10 

16-02-2010 15:06:28

nico
Webmaster
Date d'inscription: 07-08-2009
Messages: 563
Corrections: 9

merci nabouill, on m'avait toujours dit de mettre les attributs en priv ou protected, mais on m'a jamais dit les risques, l je me rend compte qu'on peut faire des allocations et tout et tout, donc c'est clair que c'est plus scuris avec les accesseurs, faut que je perde les rflexe du C.

Bon bein elle commence avoir de la gueule cette classe smile y a juste l'numration qu'il faudrait dclarer dans la classe, le problme est que quand j'apelle la fonction depuis la main, il dit que l'numration n'est pas dclar, j'ai essay de me baser sur irrlicht qui met l'numration en public mais je n'arrive rien(d'ailleurs a porte confusion de voir un attribut public, mais c'est une exception wink )
En tout cas c'est un bon exercice pour les dbutants en poo smile

Hors ligne


Options Liens officiels Caractristiques Statistiques Communaut
Corrections
irrlicht
irrklang
irredit
irrxml
xhtml 1.0
css 2.1
Propuls par FluxBB
Traduit par FluxBB.fr
Analys par
872 membres
1423 sujets
11109 messages
Dernier membre inscrit: Glider
10 invits en ligne
Aucun membre connect
RSS Feed

[ Gnre en 0.016 sec., 10 requtes excutes ]