Partage
  • Partager sur Facebook
  • Partager sur Twitter

[FAIT][Défis] #5 : Un Chronomètre

Venez vous entraîner !

    14 octobre 2011 à 18:36:08

    Bonjour à tous les zéros,

    Cette semaine, nous ne vous proposons pas un nouveau parser. Cet exercice est très abordable pour tout le monde, quel que soit le niveau : un chronomètre.

    Si vous souhaitez plus de renseignements sur les défis, rendez vous sur le topic de recensement des défis, vous y trouverez également les règles principales.

    Cet exercice a été écrit par GuilOooo, un grand merci à lui !

    Un Chronomètre



    Salut ! :)

    Le défi de la semaine sera de recréer un chronomètre. Ce défi est plutôt simple et les explications vous permettront de vous aider si vous avez des difficultés. Sachez que ce défi est accessible dès la fin de la partie 2 du tutoriel officiel du site. Passons dès à présent au cahier des charges.

    Cahier des charges


    Cet exercice serra composé de trois niveaux :

    Niveau 1 :
    Vous devrez arrivez à reproduire ce programme :
    Appuyez sur "Entrée" :
    Encore :
    Il s'est écoulé 11 secondes.

    Vous devez donc simplement calculer les temps écoulé entre les 2 "Enter". Pour cela vous pouvez utiliser les fonctions du header standard time.h. D'ailleurs, il y a un tuto à ce sujet. ;)

    Pour attendre l'appui sur la touche Entrée, vous pouvez utiliser la fonction getchar() ou encore simplement un scanf(). Les fonctions que vous devrez utiliser afin de récupérer la date sont time() et difftime(). ;)

    Niveau 2 :
    Vous devrez arrivez à reproduire ceci :
    Appuyez sur "Entrée" :
    Encore :
    Il s'est écoulé 4.255 secondes.


    La différence avec le premier ? La précision. Ici nous allons gérer une précision grandement accrue, de l'ordre de la micro seconde. ;)
    Pour cela, nous allons utiliser des fonctions différentes pour la gestion du temps, mais pour l'attente de l'appuie sur la touche Entrée, vous pouvez encore utiliser getchar() ou scanf().

    Pour le temps, cette fois ci nous allons utiliser la fonction clock() qui se base sur la fréquence du processeur. Pour retrouver un résultat en seconde, vous devrez utiliser la macro CLOCKS_PER_SEC.

    Niveau 3 :
    Les choses se gâtent. :diable:
    En effet, vous allez essayer d'afficher le temps écoulé en temps réel. Cette fois-ci, vous êtes libre du résultat, cependant, pour vous montrer un exemple voici ce que pourrait afficher votre programme :
    Appuyez sur "Entrée" :
    Encore :
    Deja 1 seconde
    Deja 2 seconde
    Deja 3 seconde
    Deja 4 seconde
    Il s'est écoulé 4.625 secondes.


    Vous pouvez arriver à ce résultat par plusieurs moyens. Le plus simple étant d'utiliser des fonctions propre à votre système mais ce n'est pas la seul solution.
    Vous pouvez :
    • Vérifier l'état de la touche Entrée grâce à des fonctions propres à votre système.
    • Faire de la programmation évènementielle grâce à des fonctions propres à votre système,
    • Utiliser le multithreading afin de gérer plusieurs threads et donc de gérer l'appui d'une touche grâce à un thread enfant.

    Il est clair que la première solution est la plus simple. Je vous laisse chercher les informations pour ce niveau, mais généralement vous trouverez très facilement grâce à votre moteur de recherche préféré. Il serait intéressant de se renseigner sur les différentes manières proposées. Il serait aussi intéressant de voir certaines personnes se pencher sur les 2 dernières méthodes qui ont été proposées ou même de réaliser ce programme par une autre méthode encore.
    Vous aurez dans tous les cas certainement besoin d'une fonction permettant d'attendre un certain temps. Pour cela, il n'existe pas de fonction portable vous pouvez :
    • Sous Windows : inclure windows.h et utiliser la fonction Sleep() (avec une majuscule).
    • Sous Linux et Mac OS : inclure unistd.h et utiliser la fonction sleep().


    Sur ce, bonne chance. ;)

    @che


    Participants



    Participants Code
    Loadware Niveau 3
    Ouss4 Niveau 3
    Lucas-84 Niveaux 1 et 2
    Tosh Niveau 3
    Taurre Niveau 3
    informaticienzero Niveaux 1 et 2
    Lucien63 Niveau 2
    GurneyH Niveau 3 (SDL)
    • Partager sur Facebook
    • Partager sur Twitter
      14 octobre 2011 à 19:46:56

      Salut,

      Citation

      Cet exercice a été écrit par GuilOooo, un grand merci à lui !



      Le défi n'est pas de @che ?
      • Partager sur Facebook
      • Partager sur Twitter
        14 octobre 2011 à 21:09:47

        Voici mon code (niveau 3) fait en 5 min, j'utilise conio pour la gestion des touches et windows pour la pause :
        #include <windows.h>
        #include <stdio.h>
        #include <conio.h>
        #include <time.h>
        
        int main(void)
        {
            int i = 0;
            clock_t c = 0, t = 0;
            
            printf("Appuyez sur \"Entree\" : ");
            getchar();
            
            t = clock();
            printf("Encore : ");
            
            while(!_kbhit() || _getch() != '\r')
            {
                if((clock() - c) / CLOCKS_PER_SEC >= 1)
        	{
        	    printf("\nDeja %d seconde", i++);
        	    c = clock();
        	}
        		
        	Sleep(20);
            }
        	
            printf("\nIl s'est ecoule %.3f secondes.\n", (float)(clock() - t) / CLOCKS_PER_SEC);
            getchar();
            
            return 0;
        }
        
        • Partager sur Facebook
        • Partager sur Twitter
          14 octobre 2011 à 21:28:14

          Citation : Loadware

          Voici mon code (niveau 3) fait en 5 min


          Sérieux, 5 min pour le niveau 3 ? o_O
          • Partager sur Facebook
          • Partager sur Twitter
            14 octobre 2011 à 21:35:37

            @Loadware: Comme dit dans l'énoncé, tu as pris la solution la plus simple (et tu as bien raison).
            Après, si tu te sens à l'aise, peut-être devrais-tu essayer la programmation événementielle. Par-contre, ça nécessite un peu de recherche ;)

            Citation : kaka551

            Citation

            Cet exercice a été écrit par GuilOooo, un grand merci à lui !


            Le défi n'est pas de @che ?

            Oh, c'est une petite erreur, tu as raison, c'est bien moi qui l'ai écrit, mais d'après l'idée de GuilOooo ;)

            @Ouss4: C'est un vrai exercice pour débutant, ici, l'exercice est plus axé sur la recherche que sur le résultat. Tu devrais essayer ;)
            • Partager sur Facebook
            • Partager sur Twitter
            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
              14 octobre 2011 à 21:42:30

              Citation : @che

              @Ouss4: C'est un vrai exercice pour débutant, ici, l'exercice est plus axé sur la recherche que sur le résultat. Tu devrais essayer ;)


              Oui oui je viens de voir le défis, je croyais qu'il était comme les précédents.

              Mais bon vais essayer de le faire après mon repas :p

              EDIT : J'ai fait le niveau 3, très similaire à celui de Loadware, je connaissais pas bien les fonctions de "conio.h" donc j'ai un peu chercher, et je dois avouer que je ne l'aurais pas fait avec si loadware n'en avait pas parler, j'aurais très probablement galérer sans "kbhit()"...


              J'ai presque oublié, le code :

              #include <windows.h>
              #include <stdio.h>
              #include <conio.h>
              #include <time.h>
              
              #if defined (WIN32) || defined (WIN64)
              #include <windows.h>
              #define _SLEEP(temps) Sleep(temps*1000)
              #else
              #include <unistd.h>
              #define _SLEEP(temps) sleep(temps)
              #endif
              
              int main(int argc, char *argv[])
              {
                  argc = 0;
                  argv = NULL;
              
              
                  int i = 0;
                  clock_t t1 = 0, t2 = 0;
              
              
                  puts("Appuyez sur Entrer\n");
                  getchar();
              
                  t1 = clock();
                  puts("Encore\n");
              
                  do
                  {
                      if((clock() - t2)/CLOCKS_PER_SEC == 1)
                      {
                          printf("Deja %d seconde\n", i++);
                          t2 = clock();
                      }
                      _SLEEP(.1);
                  }while(!kbhit());
              
                  printf("\nIl s'est ecoule : %.3lf secondes ", (double)(clock() - t1)/CLOCKS_PER_SEC);
                  getch();
                  return 0;
              }
              


              EDIT 2 : j'ai oublié de posté le niveau 1 aussi, juste pour le plaisir.
              #include <windows.h>
              #include <stdio.h>
              #include <conio.h>
              #include <time.h>
              
              int main(void)
              {
                  time_t t1 = 0, t2 = 0;
              
                  puts("Appuyez sur Entrer\n");
                  getchar();
              
                  time(&t1);
                  puts("Encore\n");
                  getchar();
                  time(&t2);
              
              
                  printf("\nIl s'est ecoule : %d secondes ", (int)difftime(t2, t1));
                  getch();
                  return 0;
              }
              
              • Partager sur Facebook
              • Partager sur Twitter
                15 octobre 2011 à 12:01:37

                Mon code gentillet pour le niveau 1 :

                /*******************************************************
                Nom ......... : main.c
                Role ........ : chronomètre
                Auteur ...... : lucas-84
                Version ..... : 15/10/2011
                Licence ..... : aucune
                
                Compilation :
                gcc -W -Wall -Wextra -pedantic main.c
                Pour exécuter, tapez :
                Windows :   ./limites.exe
                Unix :      ./a.out
                ********************************************************/
                
                /* printf() - perror() */
                #include <stdio.h>
                /* exit() - EXIT_SUCCESS */
                #include <stdlib.h>
                /* time_t - time() - difftime() */
                #include <time.h>
                
                /* void enter(const char *s);
                Entrée : une chaîne de caractère qui sera affichée
                Sortie : aucune
                Description : la fonction enter() afficher la chaîne de caractère s suivie
                d'un espace et attend que l'utilisateur appuie sur "Entrée" */
                void enter(const char *s)
                {
                    printf("%s ", s);
                    getchar();
                }
                
                /* time_t take_time(void);
                Entrée : aucune
                Sortie : nombre de secondes écoulées depuis le 1er Janvier 1970 à 00h 00m 00s
                GMT
                Description : la fonction time() retourne le nombre de secondes écoulées
                depuis le 1er Janvier 1970 à 00h 00m 00s GMT */
                
                time_t take_time(void)
                {
                    time_t t;
                    if ((t = time(NULL)) == -1) {
                        perror("time :");
                        exit(EXIT_FAILURE);
                    }
                    return t;
                }
                
                /* void print_result(int result);
                Entrée : le résultat
                Sortie : aucune
                Description : la fonction print_result affiche le temps écoulé entre les deux
                frappes sur "Entrée" */
                void print_result(int result)
                {
                    printf("Time elapsed: %d seconds.\n", result);
                }
                
                /* int calc(time_t t1, time_t t2);
                Entrée : deux temps
                Sortie : la différence entre les deux temps
                Description : la fonction calc retourne la différence entre deux temps */
                int calc(time_t t1, time_t t2)
                {
                    return (int)difftime(t2, t1);
                }
                
                /* void chrono(void);
                Entrée : aucune
                Sortie : aucune
                Description : fonction principale du programme */
                void chrono(void)
                {
                    time_t t1, t2;
                
                    enter("Press enter:");
                    t1 = take_time();
                    enter("Again:");
                    t2 = take_time();
                    print_result(calc(t1, t2));
                }
                
                int main(void)
                {
                    chrono();
                    return EXIT_SUCCESS;
                }
                


                Vous avez dit "pop-programmation" ? :-°

                Niveau 2 :

                #include <stdio.h>
                #include <stdlib.h>
                #include <time.h>
                
                void enter(const char *s)
                {
                    printf("%s ", s);
                    getchar();
                }
                
                clock_t take_time(void)
                {
                    return clock();
                }
                
                void print_result(double result)
                {
                    printf("Time elapsed: %.3lf seconds.\n", result);
                }
                
                double calc(clock_t t1, clock_t t2)
                {
                    return (double)(t2 - t1) / CLOCKS_PER_SEC;
                }
                
                void chrono(void)
                {
                    clock_t t1, t2;
                
                    enter("Press enter:");
                    t1 = take_time();
                    enter("Again:");
                    t2 = take_time();
                    print_result(calc(t1, t2));
                }
                
                int main(void)
                {
                    chrono();
                    return EXIT_SUCCESS;
                }
                


                Pour le niveau 3, je vais voir du côté multithread. ;)
                • Partager sur Facebook
                • Partager sur Twitter
                Staff désormais retraité.
                  15 octobre 2011 à 12:13:45

                  Oui lucas, pourquoi faire simple tant qu'on peut faire compliqué... :p
                  • Partager sur Facebook
                  • Partager sur Twitter
                    15 octobre 2011 à 12:24:24

                    Au fait, Ouss, tu pourrais pas faire un joli code portable ? :)
                    • Partager sur Facebook
                    • Partager sur Twitter
                    Staff désormais retraité.
                      15 octobre 2011 à 12:34:46

                      Bah pour tous les niveaux, <conio.h>, moi pas connaître. :p
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Staff désormais retraité.
                        15 octobre 2011 à 12:36:16

                        Ah d'accord, je vais chercher quelque chose pour toi alors :lol:
                        • Partager sur Facebook
                        • Partager sur Twitter
                          15 octobre 2011 à 13:25:20

                          Ma contribution pour le niveau 3 avec utilisation de select :

                          #include <stdio.h>
                          #include <stdlib.h>
                          #include <unistd.h>
                          #include <sys/select.h>
                          #include <sys/time.h>
                          #include <sys/types.h>
                          #include <time.h>
                          
                          int main(void)
                          {
                             fd_set readfds;
                             int selret;
                             struct timeval tv;
                             clock_t t;
                             int cur_sec;
                          
                             tv.tv_sec = 0;
                             tv.tv_usec = 10000;
                          
                             cur_sec = 0;
                          
                             printf("Appuyez sur \"Entrée\" :\n");
                             getchar();
                             t = clock();
                             printf("Encore : \n");
                          
                             do
                             {
                                FD_ZERO(&readfds);
                                FD_SET(STDIN_FILENO, &readfds);
                                selret = select(STDIN_FILENO+1, &readfds, NULL, NULL, &tv);
                          
                                if((clock()-t) / (double) CLOCKS_PER_SEC > cur_sec+1)
                                {
                                   cur_sec++;
                                   printf("Déjà %d seconde\n", cur_sec);
                                }
                          
                             }while(selret == 0);
                          
                             printf("Il s'est écoulé %g secondes\n", (clock() - t) / (double)CLOCKS_PER_SEC);
                          
                             return EXIT_SUCCESS;
                          }
                          
                          • Partager sur Facebook
                          • Partager sur Twitter
                            15 octobre 2011 à 13:53:36

                            Si on veut un code réellement portable on peut toujours utilise PDCurses, ça gére les touches comme il faut :)
                            • Partager sur Facebook
                            • Partager sur Twitter
                            Anonyme
                              15 octobre 2011 à 14:33:26

                              En fait c'est vraiment facile. Après les exercices précédents je m'attendais à un truc super-compliqué. ^^
                              • Partager sur Facebook
                              • Partager sur Twitter
                                15 octobre 2011 à 14:36:21

                                Salut,

                                Il y a un petit problème dans l'exercice qui est proposé. Pour le niveau 1 utilisant time et difftime il n'y a pas de soucis, par contre, pour le niveau 2, l'utilisation de clock est problématique. En effet, cette dernière retourne la meilleure approximation du temps processus utilisé par le programme depuis qu'il a été exécuté:

                                Citation : Norme C99 7.23.2.1 § 3 p 339


                                The clock function returns the implementation's best approximation to the processor
                                time used by the program since the beginning of an implementation-defined era related
                                only to the program invocation
                                . To determine the time in seconds, the value returned by
                                the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
                                the processor time used is not available or its value cannot be represented, the function
                                returns the value (clock_t)(-1).



                                Or, en faisant appel à getchar ou tout autre fonction qui ont pour effet "d'endormir" le processus, ce temps est dans ce cas nul (puisque le processeur n'est pas sollicité).
                                D'ailleurs, seuls les codes proposés par Tosh et Loadware retourne un temps non nul. En effet, celui de Tosh boucle tant qu'il n'y a rien à lire sur l'entrée standard (la fonction select bloquant au maximum le programme pendant 10 millisecondes). Celui de Loadware fait plus ou moins la même chose (je ne connais pas la fonction _kbhit :p ) en mettant le programme en pause pendant 20 millisecondes à chaque tour de boucle.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  15 octobre 2011 à 15:49:04

                                  Un chrono... but intéressant^^ (encore une fois, ce message est là pour me rappeler de le faire... un jour ^^)
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    15 octobre 2011 à 16:07:42

                                    Sinon, je poste ma participation pour le niveau 3 (Unixoïde uniquement):


                                    #define _XOPEN_SOURCE 500
                                    #include <fcntl.h>
                                    #include <time.h>
                                    #include <signal.h>
                                    #include <stdio.h>
                                    #include <stdlib.h>
                                    #include <unistd.h>
                                    
                                    
                                    static void
                                    affiche_secondes(int sig)
                                    {
                                    	static sig_atomic_t i;
                                    
                                    	(void)sig;
                                    	signal(SIGALRM, affiche_secondes);
                                    	printf("Déjà: %d secondes\n", ++i);
                                    	alarm(1);
                                    }
                                    
                                    
                                    int
                                    main(void)
                                    {
                                    	char c;
                                    
                                    	printf("Appuyez sur Enter:\n");
                                    	getchar();
                                    	printf("Encore:\n");
                                    
                                    	fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
                                    	signal(SIGALRM, affiche_secondes);
                                    	alarm(1);
                                    	while (read(STDIN_FILENO, &c, 1) == -1)
                                    		usleep(1);
                                    
                                    	alarm(0);
                                    	printf("Il s'est écoulé: %lf secondes\n", 
                                    	       clock() / (double)CLOCKS_PER_SEC);
                                    	return EXIT_SUCCESS;
                                    }
                                    



                                    Le but est d'éviter que le programme ne soit bloqué par les lectures sur l'entrée standard en utilisant l'attribut O_NONBLOCK. Pour le reste, le programme boucle et dort 1 microsecondes à chaque tour. Le programme reçoit le signal SIGALRM toutes les secondes afin d'afficher l'état du chronomètre.
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      15 octobre 2011 à 16:21:33

                                      @Taurre : je ne sais pas si c'est à cause du usleep, mais le temps écoulé n'a pas l'air correct à la fin :

                                      Appuyez sur Enter:
                                      
                                      Encore:
                                      Déjà: 1 secondes
                                      Déjà: 2 secondes
                                      
                                      Il s'est écoulé: 0.260000 secondes


                                      EDIT : c'est bien à cause du usleep :) .
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        15 octobre 2011 à 16:28:46

                                        J'avais placé l'appel à usleep histoire d'éviter que le programme n'utilise tout le cpu; en pensant que cela n'influencerait pas trop les résultats. Mais visiblement je me suis trompé :-°

                                        Merci pour la remarque ;)
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          15 octobre 2011 à 18:08:54

                                          @loadware : on peut dire que les threads sont portables, vu que MinGW en fournit une implantation également.
                                          Je n'ai pas eu le temps de finaliser mon code multithread. PS : quelqu'un pourrait-il m'expliquer des manières portables de faire de la programmation événementielle, je l'avoue curieux. :)
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          Staff désormais retraité.
                                            15 octobre 2011 à 20:38:05

                                            Je n'ai jamais entendu parler de l'implantation des threads dans MinGW... je devrais faire une recherche dessus. Perso quand j'ai besoin de faire du multithreading j'utilise la lib pthreads-win32.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              15 octobre 2011 à 20:39:07

                                              En même temps, les threads seront bientôt standards :) (C1X)
                                              Sinon, pour la programmation évènementielle, il faudrait que tu utilises des bibliothèques pour avoir un code portables. Ce n'est pas vraiment le but de l'exo, mais si ça te tente vas-y ;)
                                              Moi perso, je ne suis pas allez aussi loin :

                                              Citation : @che

                                              Faire de la programmation évènementielle grâce à des fonctions propres à votre système,



                                              Ouh mais c'est qu'il y a du monde :) C'est bien.

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                              Anonyme
                                                15 octobre 2011 à 20:49:30

                                                Voilà ma participation au niveau 1, cependant j'ai l'impression que le temps s'écoule un peu "lentement".

                                                #include <stdio.h>
                                                #include <stdlib.h>
                                                #include <time.h>
                                                
                                                int main()
                                                {
                                                    time_t tempsD, tempsF;
                                                
                                                    printf("Appuyez sur la touche Entree\n");
                                                    getchar();
                                                
                                                    time(&tempsD);
                                                
                                                    printf("Encore\n");
                                                
                                                    getchar();
                                                
                                                    time(&tempsF);
                                                
                                                    printf("Il s'est ecoule %lf secondes\n", difftime(tempsF, tempsD));
                                                    return 0;
                                                }
                                                


                                                Et voilà le niveau 2 :

                                                #include <stdio.h>
                                                #include <stdlib.h>
                                                #include <time.h>
                                                
                                                int main()
                                                {
                                                    clock_t tempsD, tempsF;
                                                
                                                    puts("Appuyez sur la touche Entree\n");
                                                    getchar();
                                                    tempsD = clock();
                                                
                                                    puts("Encore\n");
                                                    getchar();
                                                    tempsF = clock();
                                                
                                                    printf("Il s'est ecoule %.4lf secondes\n", (double)(tempsF - tempsD)/CLOCKS_PER_SEC);
                                                    return 0;
                                                }
                                                


                                                Dire que j'ai galéré tout ça pour un oublie de cast. ^^
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  15 octobre 2011 à 22:21:41

                                                  Pour Windows :


                                                  chrono.exe

                                                  -
                                                  Edité par Lucien63 23 juillet 2013 à 13:27:42

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  Je n'utilises ni linux, ni SDL, ni GTK.
                                                    16 octobre 2011 à 20:54:49

                                                    Ma solution pour le niveau 1 :

                                                    #include <stdio.h>
                                                    #include <stdlib.h>
                                                    
                                                    int main(void) {
                                                      printf("Appuyez sur Entrée !");
                                                      getchar();
                                                      printf("Appuyez une seconde fois sur Entrée !");
                                                      getchar();
                                                      printf("Il s'est écoulé 42 secondes !\n");
                                                      return EXIT_SUCCESS;
                                                    }
                                                    

                                                    Pour le niveau 2 :

                                                    #include <stdio.h>
                                                    #include <stdlib.h>
                                                    
                                                    int main(void) {
                                                      printf("Appuyez sur Entrée !");
                                                      getchar();
                                                      printf("Appuyez une seconde fois sur Entrée !");
                                                      getchar();
                                                      printf("Il s'est écoulé 42.000 secondes !\n");
                                                      return EXIT_SUCCESS;
                                                    }
                                                    

                                                    Pour le niveau 3 :

                                                    #include <stdio.h>
                                                    #include <stdlib.h>
                                                    
                                                    int main(void) {
                                                      int i;
                                                      
                                                      printf("Appuyez sur Entrée !");
                                                      getchar();
                                                      printf("Appuyez une seconde fois sur Entrée !");
                                                      getchar();
                                                      
                                                      for (i = 1; i <= 42; i++)
                                                        printf("Déjà %d secondes !\n", i);
                                                      printf("Il s'est écoulé 42.000 secondes !\n");
                                                      return EXIT_SUCCESS;
                                                    }
                                                    


                                                    Comme déjà dit plus haut, c'est pas très malin d'utiliser clock pour calculer le temps, sachant que clock utilise les cycles CPU, en utilisant une fonction bloquante (getchar) on arrive à 0 secondes d'exécution. ahah
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      16 octobre 2011 à 22:14:23

                                                      Bonsoir

                                                      Pour le niveau 3 en utilisant la SDL. :-°

                                                      Testé sour XP et ubuntu.

                                                      #include <SDL/SDL.h>
                                                      #include <stdlib.h>
                                                      
                                                      Uint32 my_callbackfunc(Uint32 interval, void *param)
                                                      {
                                                          int *pSeconds = (int *)param;
                                                          printf("Deja %d seconde%c\n", *pSeconds, *pSeconds == 1 ? ' ' : 's');
                                                      
                                                          (*pSeconds)++;
                                                      
                                                          return interval;
                                                      }
                                                      
                                                      
                                                      void run(void)
                                                      {
                                                          puts("Appuyez sur entree : ");
                                                          getchar();
                                                      
                                                          Uint32 startTime = SDL_GetTicks();
                                                          Uint32 seconds = 1;
                                                          SDL_TimerID timer = SDL_AddTimer(1000, my_callbackfunc, &seconds);
                                                      
                                                          puts("encore!");
                                                          getchar();
                                                      
                                                          printf("Il s'est ecoule %g seconde(s)", (SDL_GetTicks() - startTime) / 1000.);
                                                      
                                                          SDL_RemoveTimer(timer);
                                                      }
                                                      
                                                      
                                                      
                                                      int main(int argc, char *argv[])
                                                      {
                                                          if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
                                                          {
                                                              fprintf(stderr, "%s\n", SDL_GetError());
                                                              exit(EXIT_FAILURE);
                                                          }
                                                      #ifdef _WIN32
                                                          freopen("CON", "w", stdout);
                                                          freopen("CON", "r", stdin);
                                                      #endif
                                                      
                                                          run();
                                                      
                                                          SDL_Quit();
                                                      
                                                          (void)argc;
                                                          (void)argv;
                                                      
                                                          return 0;
                                                      }
                                                      


                                                      @Pouet:
                                                      for (i = 1; i <= 42; i++)
                                                      

                                                      :lol::lol::lol:
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Zeste de Savoir, le site qui en a dans le citron !

                                                      [FAIT][Défis] #5 : Un Chronomètre

                                                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                      × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                      • Editeur
                                                      • Markdown