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 :

Je m'interroge juste sur <ctime>

Effectivement, ce serait un peut l'équivalent de time.h plus révolue et réservé au C++ d'après 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 précis ou non.

TUpac :

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 très pratique (ça vient peut-être de moi aussi)
du coup a force de me créer des petite fonction un peu partout dans chaque projet et faire des copier coller a chaque coup, j'ai penser de créer une petite lib pour gérer ça deviendrais plus pratique.

En attendant, si vous avez des idée d'amélioration... faite signe

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 :

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

Oui, c'est vrai que j'ai hésiter un peu a la mettre celle là, mais l'idée était que ce serait plus simple pour intégrer un chrono dans un programme, car sinon on devrait récupère 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 à réflexion. (mais perso, je préfère alléger mes programmes, ce qui n'engage que moi bien sûr).

nico :

tu pourrait aussi passer par une liste d'initialisation pour les objets afin de réduire 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 :

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

Là encore, rien ne t'echappe , mais tu as raison , ça aussi sa fait partie de mon protocole de codage, je ne peut pas m'en empêcher (faudrait que je revois mes vieilles habitudes) OK je l'enlève.

nico :

cela dit c'est vraiment du chipotage hein

Oui, si on veut, mais toutes remarque est bonne à prendre et mérite réflexion.

nico :

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 dérivé  est déjà intégrer dans bien des classe (nanoSleep, uSleep...) Si quelqu'un à une idée, je suis preneur.

Dernière modification par nabouill (31-01-2010 22:18:55)

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 :

j'ai viré mon précédant 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 extrêmement important :

Même si je sais que tu va me dire "oui mais ça évite de créer des ascenseurs, ce qui allège pas mal notre code"
C'est vrai, mais ceci est INTERDIT . (j'exagère un peu hein)

2_
Sinon le

est vraiment très bon

3_
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()"
je trouve ça plus parlant.

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

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

En tout cas beau travail.

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

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 ?

nabouill :

Sinon le

Code c++ :

#define tempsActuel  clock()

est vraiment très bon

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

nabouill :

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()"

ouai, je me suis étonné moi même , la plupart du temps quand j'écris en français c'est moins compréhensible qu'en anglais , il faut dire que c'est pas evident avec les accents interdit et companies........
j'adère au "delaiEstEcoule", par contre je ne suis pas d'accord sur  "jusqu'a Intervalle"(je viens d'apprendre comment ça s'écrit ), d'àprès ce que j'ai pu comprendre, un intervalle représente 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 dépend comment on l'interprete, je pense que tu voulais dire "jusqu'a sortie de l'intervalle" ?

nabouill :

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 problème c'est que j'ai pas tout compris puisque normalement l'enumeration devrait être à l'interieur de la classe, mais je n'ai pas reussi à l'utiliser de cette façon donc je l'ai déclaré 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 même si j'ai moi même besoins de plus d'info à ce sujet


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

nico :

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

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

nico :

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 ?

Le problème que ça peut engendrer dans notre cas n'est pas bien méchant, le problème s'agrandit vite si l'on a plusieurs attribues, dont certaine qui sert a calculer certaine chose dans des méthode, des attribues que l'on utilise nul par dans notre code sauf pour faire des vérifications. Si ces attribues sont modifiable de l'extérieur, elle peuvent vite fausser toutes notre classe. Un utilisateur crée un pointeur sur cette attribue qui l'envoie a des méthodes et des méthodes 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 plutôt que dire "celle là je la privatise, pas celle là ça va être plus simple..." Il est préférable de toutes les privatisé directement car le simple ajout d'une méthode par la suite peut vite faire changer d'avis.

nico :

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 même si je pense que l'on peut trouver mieu. Si quelqu'un a une idée...

nico :

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

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


Bon, du coup je regarde ça, et je remet tout au propredès que j'ai un peu de temps, e, attendant, si il y a d'autre idée, faite signe

Dernière modification par nabouill (13-02-2010 21:55:55)

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