Discussion :

[atomicJo]

bonjour, je recherche un moyen de faire une pause de durée paramètrable (en milliseconde de préférence) dans une boucle for ou while, ma boucle va parcourir un tableau d'images que je veux afficher plus ou moins rapidement.
le programme donnerai à peu près ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
for(int i=0;i<taille;i++)
{
     afficher(tab[i]);
     pause(500); //ici ma pause de 500ms
}

y a t-il une telle fonction dans les librairies de bases?

merci de vos réponses

[Neitsa]

Bonjour,

la fonction sleep() est disponible sur la plupart des systèmes et permet de mettre en pause un thread.

Toutefois, j'imagine que si tu affiches des images tu dois disposer d'un GUI. Hors, si l'on met en pause le thread qui s'occupe du GUI, l'interface graphique va aussi être "gelée".

Il faut alors mettre en place un programme multi-thread où on ne mettera en pause que le thread chargé d'afficher les images, sans que cela gèle l'interface utilisateur.

[atomicJo]

je n'ai peut etre pas donné suffisamment de précision, il s'agit d'un programme de type MFC avec une fonction d'affichage écrite à la main (utilisation de StretchDIBits).
la fonction sleep() va t-elle bloquer tout l'affichage?
j'ai essayé de l'utiliser dans un programme tout simple, mais la fonction n'est pas reconnue :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
#include "stdlib.h"
#include "time.h"
 
using namespace std;
 
void main(){
	for(int i=0;i<5000;i++)
	{
		cout<<i<<" ";
		sleep(2000);
	}
}

faut-il inclure d'autres librairies ?

[Mat007]

Salut,

Dans l'API Windows c'est Sleep avec au besoin windows.h à inclure si ce n'est pas déjà fait dans ton application.

MAT.
ps: en français on dit une bibliothèque et non une librairie (c'est ce qu'on appelle un faux ami)

[atomicJo]

salut, même en incluant la bibliothèque winows.h la fonction sleep n'est toujours pas reconnue

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <iostream>
#include <windows.h>
 
using namespace std;
 
void main(){
	for(int i=0;i<5000;i++)
	{
		cout<<i<<" ";
		sleep(2000);
	}
}

error C3861: 'sleep' : identificateur introuvable

help!!

[Mat007]

Avec un S majuscule.

MAT.

[souviron34]

Il faut alors mettre en place un programme multi-thread où on ne mettera en pause que le thread chargé d'afficher les images, sans que cela gèle l'interface utilisateur.

Rhaaaaaa

vous m'énervez avec vos threads et multi-threads....

Un peu d'imagination, que diable !!!!

Un exemple en C :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
*
 *  F S l e e p 
 *
 */
static void  FSleep ( Interface_Data *idata, double Secs, 
                      int Acceleraion, int t_start, void *UpdateDipslay(void*) )
{
  int                      Statut,  s ;
  clock_t                  Saved_Clock, Actual_Clock, Clock1000 ;
  double                   diff, MilliSecs, Secs_Demandees, Clocks_Per_MilliSec ;
  time_t                   t_verif ;
  struct tm               *Saved ;
  
  if ( Secs <= 0.0 ) return ;
 

/*
--- Calcule combien de millisecondes on doit attendre
*/
  if ( Acceleration > 0 )
      Secs_Demandees = Secs / (double)(Acceleration) ;
  else
      Secs_Demandees = 3600 ;

  Clocks_Per_Millisec = (double)CLOCKS_PER_SEC / 1000.0 ;

  MilliSecs = (double)( (int)(Secs_Demandees * 1000.) ) ;
  if ( t_start != -1 )
    {
        t_verif = t_start ;
        Saved = gmtime((time_t *)&t_verif) ;
    }

  Statut = 0 ;
  Saved_Clock = clock();
  Clock1000 = Saved_Clock ;

/*
--- Attend ce nombre, et verifie toute les secondes si on n'a pas
    interrompu l'attente
*/
  while ( Statut != 1 )
   {
        UpdateDisplay ( (void *)idata ); /* ICI on appelle  la fonction d'update à chaque passe */

        Actual_Clock = clock();
        diff = (double)(Actual_Clock - Saved_Clock) / Clocks_Per_MilliSec ;

        if ( diff >= MilliSecs ) /* ici on a fini l'attente */
           {
               break ;
           }

/*
--- Chaque seconde
*/
        if ( (double)((Actual_Clock - Clock1000)/Clocks_Per_MilliSec) >= 1000.0 )
          {
               Clock1000 = Actual_Clock ; 
               /* Verifie certains paramètres */
              /* Si attente interrompue (par flag ou autre) sort */
          }
        else
          {
               if ( Acceleration == 0 ) /* Si on s'est mis en "pause", vérifie quand même chaque seconde */
                     sleep (1);

               /* sinon boucle et va mettre à jour le GUI à chaque CYCLE d'horloge */
          }
   }
}

[JolyLoic]

vous m'énervez avec vos threads et multi-threads....

Un peu d'imagination, que diable !!!!

Donc, si j'ai bien compris, pour ne pas faire de multithread, tu remplaces ça par une attente active, qui bouffe toutes les ressources de la machine, consomme plein d'électricité et fait dégager au processeur tout plein de chaleur sans autre but que d'accélérer le réchauffement climatique ?

[souviron34]

parce que tu crois que ça ne fait pas ça avec des threads ?????????


et je te signale que ça ne fait pas plus d'attente active que le MainLoop de l'outil graphique, puisque c'est celui-ci qu'on appelle quand on fait "Update_Display"..

Plus précisément, le MainLoop fait DispatchEvent
Eh bien cette routine que dans l'exemple j'ai appelée Update_Display fait ça...

C'est tout...

ça permet de faire de l'attente dans un GUI sans que le GUI gèle, et de manière portable...et sans avoir besoin de s'em...er avec des threads...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
static void Update_Display ( void *data )
{
Interface_Data *idata = (Interface_Data *)data ;
 
    DispatchEvent(idata); /* Pour avoir les éléments graphiques */
}

j'aimerais bien que tu m'expliques comment tu penses que ça marche, un gestionnaire graphique....



Si tu m'en trouves un qui ne fonctionne pas suivant le schéma suivant, tu as gagné....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void MainLoop ( ...)
{
   while ( 1 ) 
     {
        Get_Event(&event);
        Dispatch_Event(event);
     }
}

[Biozic]

Si la boucle est gérée par l'OS qui envoie un évènement à intervalles de temps régulier au callback d'affichage (timer), ça fait pas une boucle de moins qui tourne sur le système?

Et pour le gestionnaire d'affichage, c'est pas plutot un switch sur les messages envoyés pas l'OS qu'un while, ce qui permet aussi d'avoir une boucle en moins qui tourne?

Désolé, je suis pas expert.