SDL2 Afficher l'heure Fermé

Question

Bonjour, 

Pour la librairie SDL2 sous Win7?

Je souahite afficher l'heure et un chronometre dans 2 surfaces distincte. Mon probleme reside dans la soustraction des chaines. Je sais qu'avec     difftime (&chrono,&tm_now);  je peux calculer la difference de temps mais je n'arrive pas a l'afficher

Je recupere le temps de lancement du programme

//DEpart Chrono
    time_t chrono = time(NULL);
    struct tm tm_chrono = *localtime (&chrono);
    strftime (chronox, sizeof chronox, "%H:%M:%S", &tm_chrono);


Ici la fonction qui me sert d'horloge:

//Fonction Temps
    time_t now = time (NULL);
    struct tm tm_now = *localtime (&now);
    strftime (xtime, sizeof xtime, "%H:%M:%S", &tm_now);

//J'affiche la variable xtime de type char
 sprintf(xtime, "%s",xtime);

  
//Le chronox doit m'afficher le temps depuis le lancement du programme mais je sais pas comment manipuler la fonction difftime()  
sprintf(chronox, "%s",chronox);

Configuration: Windows 7 / Chrome 52.0.2743.116

mamiemando · Answer

Bonjour,

Je suppose que xtime est de type char *, pas char.

Ensuite si tu veux calculer une différence de temps (et manipuler plus généralement un temps), passer par des chaînes est une mauvaise idée, car les fonctions qui servent à manipuler du temps sont basées sur des valeurs numériques.

Il faut donc représenter le temps dans ton programme des valeurs numériques,  ...
https://stackoverflow.com/questions/16275444/how-to-print-time-difference-in-accuracy-of-milliseconds-and-nanoseconds-from-c

... et uniquement passer vers les chaînes de caractères au moment de l'afficher dans ton interface graphique.
https://stackoverflow.com/questions/3673226/how-to-print-time-in-format-2009-08-10-181754-811

Bonne chance

mamiemando · Answer

Bonjour Voici une manière de faire : #include // fputs #include // time #include // sleep #include // strftime, difftime void fprintf_tm(FILE * stream, const char * format, const struct tm * tm_info) { const unsigned buffer_size = 100; char buffer[buffer_size]; strftime(buffer, buffer_size, format, tm_info); fputs(buffer, stream); } void fprintf_time(FILE * stream, const char * format, const time_t * t) { fprintf_tm(stream, format, localtime(t)); } void printf_time(const time_t * t) { fprintf_time(stdout, "%Y:%m:%d %H:%M:%S", t); } int main() { time_t t1, t2; // Measure t1, wait 2s, measure t2. t1 = time(NULL); sleep(2); t2 = time(NULL); // Print results printf("t1 = "); printf_time(&t1); printf(" t2 = "); printf_time(&t2); printf(" delta = %lf ", difftime(t2, t1)); return EXIT_SUCCESS; } Résultat : (mando@aldur) (~) $ gcc toto.c && ./a.out t1 = 2016:08:30 15:15:33 t2 = 2016:08:30 15:15:35 delta = 2.000000 Maintenant regardons un peu plus en détail "l'idée". time_t est le type que l'on mesure. On peut facilement faire la différence entre deux time_t. struct tm sert principalement à faire le "rendu". On va donc masquer cette complexité dans print_time. Il faut convertir le time_t en struct tm pour enfin pouvoir exploiter strftime. Malheureusement cette fonction requiert un buffer. On va une fois encore cacher ce détail d'implémentation dans notre fonction dédiée à l'affiche d'un struct tm, la fonction que j'ai appelée fprintf_tm. On voit que celle-ci laisse le choix du flux dans lequel on écrit (fichier, sortie standard, etc...) et dans le format, donc autant laisser cette flexibilité. Flexibilité que je répercute dans fprintf_time. Maintenant en pratique on va utiliser toujours le même flux (stdout) et le même format, et la fonction print_tm va me permettre de masquer tout ceci. À ce stade on a le design (les paramètres et les fonctions) du programme et on voit comment emboîter les fonctions. Reste à gérer les pointeurs. Ici toutes mes fonctions prennent des pointeurs. Il suffit donc que dans le main je passe des pointeurs. Le mot clé const permet de préciser ce qui ne sera pas modifié par la fonction (il est donc mieux de les mettre, ça améliore la lisibilité du programme, sa rigueur, et surtout c'est plus générique). Les pointeurs Les pointeurs ensuite ce n'est pas très compliqué. Une adresse indique o quelque chose se trouve. Moralement, c'est un entier, donc quelque soit l'adresse dont on parle elle fait toujours la taille d'un entier (32 bits sur un système 32 bits, 64 sur un système 4 bits). Une adresse générique se note void * et donne un accès en lecture et écriture à cet endroit. Un const void * ne donne qu'un accès en lecture. Le "problème", c'est qu'on peut parler de l'adresse de choses qui ne font pas la même taille. Un uint32_t ou char ne font pas la même taille par exemple. Pour spécifier la taille de l'objet pointé, on type le pointeur pour indiquer ce qu'on est sensé y trouver. Par exemple un uint32_t * signifie qu'on pointe à priori sur quelque chose qui fait la taille d'un uint32_t (soit 32 bits). Ensuite la syntaxe est simple : ce qui est l'adresse p (comme pointeur) est atteint par *p. À ce stade, le programme tentera de lire sizeof(*p) octets à l'adresse p. Si p n'est pas une adresse correctement initialisée tu auras une erreur de segmentation (erreur mémoire). Ce genre d'erreur se débogue typiquement avec gdb. A contrario, l'adresse un objet o s'obtient avec &o. On retrouve en outre que parler de *p si p est de type void * n'aura pas de sens (on ne sait pas quelle taille lire). L'opérateur * n'est donc défini que sur des pointeurs typés. On peut une fois la taille d'une case (de l'objet pointé) définir un décalage avec l'opérateur +. Par exemple si p est de type uint32_t, p + i revient à se décaler de i*sizeof(uint32_t) = 32*i bits par rapport à p. Pour accéder à la ième case d'un tableau, il suffit donc de connaître l'adresse de sa première case et de se décaler de i cases. Avec cette syntaxe, si on renomme p en tab, cela donnerait uint32_t x = *(tab + i). Mais cette syntaxe est un peu lourde donc on définit l'opérateur [ ] : tab[i] correspond exactement à *(tab+i). En particulier si i = 0, on retrouve le fait que la première case du tableau est stockée à l'adresse tab, donc tout est cohérent. Vu qu'* requiert un pointeur typé, il en est mécaniquement de même pour [ ]. Par ailleurs, rien ne garantit que si on parle de tab[1000], ceci tombe à une adresse "réservée" par le programme. Si ce n'est pas le cas et que tu y accèdes, tu auras probablement une erreur mémoire. Ou pire, si ça tombe sur de la mémoire utilisée par ailleurs par ton programme, tu risques d'écraser ou de lire des choses qui n'ont rien à voir avec ton tableau. Ce genre d'erreur se débogue avec un outil comme valgrind. Quoiqu'il en soit, les opérateurs définis sur les pointeurs permettent de faire "comme si" on manipulait un tableau (sous réserve qu'il soit alloué en mémoire). C'est pourquoi il n'y a pas de type "tableau" à proprement parler en C. Reste à traiter le fait de réserver et relâcher une zone mémoire. C'est respectivement fait par malloc (ou calloc) et par free. Le schéma typique est : uint32_t * block = malloc(1000*sizeof(uint32_t)); if (block) { // Je peux accéder à bloc[0]...bloc[999] // Quand j'ai fini : free(block); } else { // Plus assez de mémoire } Après si tu veux aller plus loin sur les pointeurs, tu peux regarder comment faire des liste chaînes, des arbres, des matrices à n dimensions, etc... Bonne chance

SDL2 Afficher l'heure

2 réponses

Discussions similaires