Historique des modifications - Message

Message #7837

Sujet: Gestion tu temps, créez votre propre "library"


Type Date Auteur Contenu
Dernière modification 31-01-2010 21:16:34 nabouill
[intro] Créez votre propre library pour gérer le temps dans vos programmes.
Pour appeler une fonction à interval régulier, savoir combien de temps s'est écoulé depuis l'instant T, mettre le programme en pause pour alléger un peu les ressource demander au CPU, récupérer le temps écoulé pour faire un compteur ... [/intro]


Voici une petite classe que je ne cesse d'améliorer, très simple mais très pratique. je vais directement mettre le code et on va voir ensuite ce qu'on peu en faire.

ancres->set(Le code, Comment ça marche ?, mettre ça en DLL);

ancres->create(Le code);
Commençons 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);  //redéfini l'interval
        void waitUntilInterval();        //endort le programme jusqu'a ce que l'interval soit dépassé
        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);
}


ancres->create( 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 dépassé
if(timer.isExceed())
{
      //je fais mon truc
}

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

//je recupère mon interval
int intervalTemp = timer.getInterval();


Faire une pause, alléger 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();


Chronmètre / compte à rebour:

Code c++ :

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

//**** exemple chronomètre

while(1)
{
     cout << timer.getTimeExceedMs() << endl; //affiche le temps ecoulé depuis le début du timer (en ms)
     cout << timer.getTimeExceedSc() << endl; //affiche le temps ecoulé depuis le début du timer (en seconde)
       /*je me permet de préciser que cette méthode ne reset jamais le timer,
          donc peut importe son interval défini il continuera indéfiniment*/
}

//**** 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 réinitialiser, donc attention si vous ne souhaiter pas rentrer dans les valeurs négative
          la mise en place d'un   if(timer.isExceed()) peut s'avérer utile pour arrêter pile a 0 */
}




ancres->create( mettre ça en DLL);


Pour une utilisation fréquente dans vos programmes, je vous propose de créer un lib pour facilité sont intégration.

Avec Code::Blocks créez un projet "Dynamic Link Library", supprimez les fichiers crée automatiquement.
Puis créer 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 fainéant ... si si je sait qu'il y en a wink )
je vous laisse les télécharger 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...
Création du message 28-01-2010 12:44:40 nabouill
[intro] Créez votre propre library pour gérer le temps dans vos programmes.
Pour appeler une fonction à interval régulier, savoir combien de temps s'est écoulé depuis l'instant T, mettre le programme en pause pour alléger un peu les ressource demander au CPU, récupérer le temps écoulé pour faire un compteur ... [/intro]


Voici une petite classe que je ne cesse d'améliorer, très simple mais très pratique. je vais directement mettre le code et on va voir ensuite ce qu'on peu en faire.

ancres->set(Le code, Comment ça marche ?, mettre ça en DLL);

ancres->create(Le code);
Commençons 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);  //redéfini l'interval
        void waitUntilInterval();        //endort le programme jusqu'a ce que l'interval soit dépassé
        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);
}


ancres->create( 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 dépassé
if(timer.isExceed())
{
      //je fais mon truc
}

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

//je recupère mon interval
int intervalTemp = timer.getInterval();


Faire une pause, alléger 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();


Chronmètre / compte à rebour:

Code c++ :

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

//**** exemple chronomètre

while(1)
{
     cout << timer.getTimeExceedMs() << endl; //affiche le temps ecoulé depuis le début du timer (en ms)
     cout << timer.getTimeExceedSc() << endl; //affiche le temps ecoulé depuis le début du timer (en seconde)
       /*je me permet de préciser que cette méthode ne reset jamais le timer,
          donc peut importe son interval défini il continuera indéfiniment*/
}

//**** 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 réinitialiser, donc attention si vous ne souhaiter pas rentrer dans les valeurs négative
          la mise en place d'un   if(timer.isExceed()) peut s'avérer utile pour arrêter pile a 0 */
}




ancres->create( mettre ça en DLL);


Pour une utilisation fréquente dans vos programmes, je vous propose de créer un lib pour facilité sont intégration.

Avec Code::Blocks créez un projet "Dynamic Link Library", supprimez les fichiers crée automatiquement.
Puis créer 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 fainéant ... si si je sait qu'il y en a wink )
je vous laisse les télécharger 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...

Retour

Options Liens officiels Caractéristiques Statistiques Communauté
Préférences cookies
Corrections
 irrlicht
irrklang
irredit
irrxml
 Propulsé par Django
xhtml 1.0
css 2.1
 884 membres
1440 sujets
11337 messages
 Dernier membre inscrit: Saidov17
166 invités en ligne
membre en ligne: -
RSS Feed