Merci nabouill, cette classe à l'air pratique.
Je m'interroge juste sur <ctime>, je sais plus trop où sur le net, j'ai récupéré une classe exemple qui utilise la fréquence de l'horloge pour chronométrer, Donc je voulais savoir si il y a des différences au niveau de la précision ? télécharger exemple 64 bit

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

Merci à vous.

nico Ecris:

Je m'interroge juste sur <ctime>

TUpac Ecris:

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

coucou, comme amélioration je verrai bien une suppression des fonctions qui retournent le temps en seconde,
je trouve que ça alourdi la classe et qu'il serait préférable d'adopté une solution plus succinte.
tu pourrait aussi passer par une liste d'initialisation pour les objets afin de réduire 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 française en option tongue

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

nico Ecris:

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

nico Ecris:

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

nico Ecris:

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

nico Ecris:

cela dit c'est vraiment du chipotage hein

nico Ecris:

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

salut, j'ai viré mon précédant 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 dépassé
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 chronomètre : " << monTimer.recupTempsEcoule() << endl;

monTimer.interval=5000;

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

return 0;
}

nico Ecris:

j'ai viré mon précédant post qui racontait n'importe quoi

     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;

#define tempsActuel  clock()

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

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

     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;

nabouill Ecris:

Sinon le

Code c++ :

#define tempsActuel  clock()

est vraiment très bon

nabouill Ecris:

Ta traduction française passe plutôt 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()"

nabouill Ecris:

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;

nico Ecris:

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

nico Ecris:

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-même ? pourtant tu as raison que c'est une règle de base, mais j'avoue ne pas comprendre les problèmes que ça peut engendrer ?

nico Ecris:

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

nico Ecris:

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

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 sécurisé avec les accesseurs, faut que je perde les réflexe du C.

Bon bein elle commence à avoir de la gueule cette classe y a juste l'énumération qu'il faudrait déclarer dans la classe, le problème est que quand j'apelle la fonction depuis la main, il dit que l'énumération n'est pas déclaré, j'ai essayé de me baser sur irrlicht qui met l'énumération en public mais je n'arrive à rien(d'ailleurs ça porte à confusion de voir un attribut public, mais c'est une exception )
En tout cas c'est un bon exercice pour les débutants en poo