Decompte du temps [Résolu]

Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 18:54 - Dernière réponse :
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:59
Bonjiours, je recherche une fonction qui effecturait un decompte du temps en lancant le programme et ensuite je cherche un moyen d'obtenir le temps qu'a durée une certaine periode déterminer! EX: entre la 15iéme et la 20iéme secondes il s'est ecoulé 5 seconde!!!
J'ai des piste qui parle d'une fonction clock() et d'une autre appeller "clock_per_sec" mais je ne parvient pas a m'en servir!!!
Afficher la suite 

Votre réponse

16 réponses

Messages postés
224
Date d'inscription
mardi 12 août 2003
Dernière intervention
18 octobre 2010
- 21 avril 2006 à 19:44
0
Merci
ya bien la fonction C time (time.h), mais je suis pas sûr que c'est ce que tu cherche...
Commenter la réponse de bayeto
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 20:45
0
Merci
c'est une fonction qui m'a servi a evaluer le temps d'execution d'un programme avec different algos. Il y a des trucs qui ne te serviront à rien mais peut etre y a t il quelques idees a prendre.

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>

/******************************************************************************/
/* Gestion d'un chronometre pour evaluer les performances du programme */
/******************************************************************************/

//#include "global.h"
//#include "chrono.h"
#include <time.h>

#define VRAI (1)
#define FAUX (0)

typedef enum { TZERO, DEPINI, FININI, DEPMC, FINMC, DEPFS, FINFS, DEPTRI,
FINTRI, DEPAFF, FINAFF, DEPLIB, FINLIB, TZZ } StatutDuProgramme;

typedef
enum { METHODELEX = 1, METHODEPRJ, METHODELP, METHODEARB, METHODELA, METHODEPA,
METHODELAP, METHODENUL } Methode;

clock_t
TZero = 0,
TDepInitialisation = 0,
TFinInitialisation = 0,
TDepFichierMotsClefs = 0,
TFinFichierMotsClefs = 0,
TDepFichierSource = 0,
TFinFichierSource = 0,
TDepTri = 0,
TFinTri = 0,
TDepAffichage = 0,
TFinAffichage = 0,
TDepLiberation = 0,
TFinLiberation = 0;

void AfficherTempsFormate (clock_t n) {

if ( n < 1000 )
printf ("%d", n);
else {
AfficherTempsFormate (n / 1000);
printf (" %03d", n - 1000 * (n / 1000));
}
}

typedef enum { NANOSECONDE, PICOSECONDE, MICROSECONDE, MILLISECONDE, SECONDE,
HEURE, JOUR } DivTemps;

void ConvertirClockEnTemps (clock_t NbClocks, clock_t TTClocks) {
register clock_t Temps, Ecoule;
register int base =
(CLOCKS_PER_SEC >= 1000000) ? MICROSECONDE :
(CLOCKS_PER_SEC >= 1000) ? MILLISECONDE :
SECONDE;
register DejaEcrit = FAUX;

/* Convertir les NbClocks en secondes */
Ecoule = NbClocks;
Temps = NbClocks / CLOCKS_PER_SEC;
TTClocks /= CLOCKS_PER_SEC;

if ( Temps < 60*60*24 && TTClocks < 60*60*24) goto ConvertirHeure;
if ( Temps >= (60*60*24) ) {
printf ("%3d J ", Temps / (60*60*24) );
Ecoule -= ((Temps / (60*60*24)) * (60*60*24)) * CLOCKS_PER_SEC;
Temps -= (Temps / (60*60*24)) * (60*60*24);
DejaEcrit = VRAI;
} else printf (" ");

ConvertirHeure:
if ( Temps < 60*60 && TTClocks < 60*60 && !DejaEcrit ) goto ConvertirMinute;
if ( Temps >= (60*60) ) {
printf ("%2d h ", Temps / (60*60));
Ecoule -= ((Temps / (60*60)) * (60*60)) * CLOCKS_PER_SEC;
Temps -= (Temps / (60*60)) * (60*60);
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 h ");
else printf (" ");

ConvertirMinute:
if ( Temps < 60 && TTClocks < 60 && !DejaEcrit ) goto ConvertirSecondes;
if ( Temps >= 60 ) {
printf ("%2d min ", Temps / 60);
Ecoule -= ((Temps / 60) * 60) * CLOCKS_PER_SEC;
Temps -= (Temps / 60) * 60;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 min ");
else printf (" ");

ConvertirSecondes:
if ( Ecoule < CLOCKS_PER_SEC && TTClocks == 0 && !DejaEcrit ) goto ConvertirMillisecondes;
if ( Ecoule >= CLOCKS_PER_SEC ) {
printf ("%2d s ", Ecoule / CLOCKS_PER_SEC);
Ecoule -= (Ecoule / CLOCKS_PER_SEC) * CLOCKS_PER_SEC;
Temps -= Temps / CLOCKS_PER_SEC;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 s ");
else printf (" ");

ConvertirMillisecondes:
if (Temps !0 && Ecoule 0) return;

/* traiter les millisecondes */
if (base < SECONDE) {
if (Ecoule >= CLOCKS_PER_SEC/1000 && Ecoule != 0) {
printf ("%3d ms ", Ecoule / (CLOCKS_PER_SEC/1000));
Ecoule -= (Ecoule / (CLOCKS_PER_SEC/1000)) * (CLOCKS_PER_SEC/1000);
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 ms ");
else printf (" ");
}

/* traiter les microsecondes */
if (base < MILLISECONDE) {
if (Ecoule > CLOCKS_PER_SEC/1000 && Ecoule != 0) {
printf ("%3d mms ", Ecoule/1000);
Ecoule -= (Ecoule/1000) * 1000;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 mms ");
else printf (" ");
}

printf ("(");
if (NbClocks) {
AfficherTempsFormate(NbClocks);
printf (" clocks");
}
else
printf("hors capacite");
printf(")\n");
}

clock_t LireLeChrono (StatutDuProgramme NumStat) {

switch (NumStat) {
case TZERO : return TZero = clock(); break;
case DEPINI: return TDepInitialisation = clock(); break;
case FININI: return TFinInitialisation = clock(); break;
case DEPMC : return TDepFichierMotsClefs = clock(); break;
case FINMC : return TFinFichierMotsClefs = clock(); break;
case DEPFS : return TDepFichierSource = clock(); break;
case FINFS : return TFinFichierSource = clock(); break;
case DEPTRI: return TDepTri = clock(); break;
case FINTRI: return TFinTri = clock(); break;
case DEPAFF: return TDepAffichage = clock(); break;
case FINAFF: return TFinAffichage = clock(); break;
case DEPLIB: return TDepLiberation = clock(); break;
case FINLIB: return TFinLiberation = clock(); break;
default : break;
}
}

void AfficherLesResultatsDuChrono (int Methode) {
#define TT (TFinLiberation - TDepInitialisation)

printf ("\nTemps d'execution :\n");
switch (Methode) {
case METHODEPRJ: case METHODEARB:
printf ("Initialisation : ");
ConvertirClockEnTemps(TFinInitialisation - TDepInitialisation, TT);
printf ("Lecture des mots clefs : ");
ConvertirClockEnTemps(TFinFichierMotsClefs - TFinInitialisation, TT);
printf ("Tri : ");
ConvertirClockEnTemps(TFinTri - TFinFichierMotsClefs, TT);
printf ("Lecture du fichier source : ");
ConvertirClockEnTemps(TFinFichierSource - TFinTri, TT);
printf ("Affichage : ");
ConvertirClockEnTemps(TFinAffichage - TFinFichierSource, TT);
printf ("Liberation des ressources : ");
ConvertirClockEnTemps(TFinLiberation - TFinAffichage, TT);
break;
case METHODELEX:
printf ("Initialisation : ");
ConvertirClockEnTemps(TFinInitialisation - TDepInitialisation, TT);
printf ("Lecture du fichier source : ");
ConvertirClockEnTemps(TFinFichierSource - TFinInitialisation, TT);
printf ("Tri : ");
ConvertirClockEnTemps(TFinTri - TFinFichierSource, TT);
printf ("Affichage : ");
ConvertirClockEnTemps(TFinAffichage - TFinTri, TT);
printf ("Liberation des ressources : ");
ConvertirClockEnTemps(TFinLiberation - TFinAffichage, TT);
break;
}
printf ("TEMPS TOTAL POUR LA METHODE : ");
ConvertirClockEnTemps(TT, TT);
}
#undef TT

void AfficherLeTempsFinal (void) {
clock_t t;
printf ("\nTemps total d'execution : ");
ConvertirClockEnTemps(t = clock() - TZero, t);
}

/******************************************************************************/
/******************************************************************************/
/* main() : */
/* Fonction principale qui appelle tout le monde */
/******************************************************************************/
/******************************************************************************/
int main (int argc, char **argv) {
int i = 1; /* indice de l'argument suivant a lire */
register int err = EXIT_SUCCESS;

LireLeChrono(TZERO); /* Initialiser le chronometre */

for (i = 0; i < 1000000; i++); // Par exemple

AfficherLeTempsFinal(); /* Fin du chrono */

return err;
}
Commenter la réponse de cs_AlexN
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:18
0
Merci
Attention code pas trop portable
la macro CLOCK_PER_SEC est dependant de la machine si je me souviens bien (tous les processeurs ne font pas le même nombre de clicks en 1 seconde).
Commenter la réponse de cs_AlexN
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:21
0
Merci
ok, merci!! je suis en train d'essayer d'afficher le temps en seconde qui defile sur la console mais je doit oublier quelque chose!peut tu me le dire!!
voici la fonction :
void main ()
{int n,i;

n=100;
for(i=0;i<n;i++)
{system("cls");
i=clock_t()/CLOCKS_PER_SEC;
printf("%d",i);

}getch();
}
Commenter la réponse de florian1121
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:23
0
Merci
non en fait probleme resolut!! mais progression d chiffre en milliseconde , comment faire l'avoir en seconde?
Commenter la réponse de florian1121
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:28
0
Merci
la conversion des clocks machine en temps "human readable" est dans la fonction ConvertirClockEnTemps()
Commenter la réponse de cs_AlexN
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:33
0
Merci
dans quelle bibliotheque machine se trouve t-elle cette fonction?
ou plutot comment la faire marcher?
Commenter la réponse de florian1121
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:37
0
Merci
lol
fais un copier coller de ma réponse plus haut

include <http://www.cppfrance.com/forum.v2.aspx?ID=720800>
Commenter la réponse de cs_AlexN
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:41
0
Merci
je sait bien qu'il faut faire copier coller!!!
mais une fois dans la fonction ca ne marche pas,
je veut dire quel #include faut il pour qu'elle fonctionne?
Commenter la réponse de florian1121
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:47
0
Merci
comment la faire marcher ?

l'appel LireLeChrono(TZERO); en debut de programme initialise la variable TZero qui contient le temps de depart
la fonction AfficherLeTempsFinal(); en fin de programme fait le reste
Commenter la réponse de cs_AlexN
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:50
0
Merci
pour les include regardes en haut de la reponse il y sont tous et il y en a peut etre meme trop

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <time.h>
Commenter la réponse de cs_AlexN
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:51
0
Merci
Ah ok, convertirclockentemps() c tte ta fonction qui est plus haut!!
j'avait rien compris dsl!!!
c trop compliquer pour moi ca, lol!!!
mais g trouver ce qu'il me fallait avec ma petite fonction un peu plus haut, essaye la tu verra, c t seulement ca que je recherchait!!
Commenter la réponse de florian1121
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:54
0
Merci
c'est d'ailleurs dans time.h qu'est definie la macro CLOCK_PER_SEC
Commenter la réponse de cs_AlexN
Messages postés
719
Date d'inscription
lundi 5 décembre 2005
Dernière intervention
8 janvier 2014
- 21 avril 2006 à 21:57
0
Merci
l'essentiel c'est que tu ais ce que tu cherchais :o)
salut
Commenter la réponse de cs_AlexN
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:59
0
Merci
Oui merci a tous pour votre aide!!
Je risque de vous embeter encore un peu plus tard pour d'autre probleme, lol!!!!
salut
Commenter la réponse de florian1121
Messages postés
37
Date d'inscription
jeudi 20 avril 2006
Dernière intervention
26 avril 2006
- 21 avril 2006 à 21:28
-2
Merci
Probleme a nouveau resolut voici la fonction qui marche:

void main ()
{int n,i;

n=100;
i=clock_t()/CLOCKS_PER_SEC;

for(i=0;i<n;i++)
{system("cls");
_sleep(1000);
printf("%d",i);

}getch();
}
Commenter la réponse de florian1121

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.