Problème dans une boucle

Bonjour.

Alors voila, mon problème est le suivant:

J'ai une boucle while dans laquelle je fais un certain nombre de choses et donc forcément cela prend du temps... Cependant, le problème est que lorsque le programme rentre dans cette boucle, je ne peux plus cliquer sur aucun bouton de la form. Et justement, ce que je veux faire, c'est de pouvoir interrompre cette boucle en cliquant sur un bouton de la form.

J'ai vu qu'en langage basic existe l'instruction "DoEvents". Y a-t-il un équivalent en C++ ?
Ou y a-t-il une solution à mon problème ?

merci

Je vois qu'une solution: tu créés un thread qui effectue tout on gros calcul, et tu l'interrompt éventuellement si tu cliques sur le bouton.

Personnellement je trouve ca tres mauvais comme programmation car tu créé un programme qu'on ne peut arretter  que grace a ctrl+alt+suppr (tu bloque TOUT les message passé a cette application).
Et tu obligé de faire une boucle (pour la performance) tu peut faire tout simplement par exemple

bool boucle;

LRESULT CALLBACK MainProc(HWND Dlg,UINT message,WPARAM wParam,LPARAM lParam)
{

        if (boucle) maboucle()

switch(message)
{
...
...
         }
}

void maboucle (void) {
i+=1;
...
...
if (i>1000) boucle = false;
}

Désolé pour les fautes j'avoue (j'ai pas relu) sinon encore mieux (la boucle ne se fera QUE si il n'y aucun message a traiter

MSG Msg;

//boucle principale
// On initialise une première fois notre message
PeekMessage(&Msg, hwnd, 0, 0, PM_NOREMOVE);

   // On boucle tant qu'on n'a pas reçu le message WM_QUIT
while (Msg.message != WM_QUIT)
{
// Y a t-il un message à traiter ?
if (PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE))
{
// Oui : on le traduit et on le dispatche
TranslateMessage(&Msg);
DispatchMessage(&Msg);

}
else {
                   maboucle()
                }
        }
}

Et evidement la procedure maboucle() n'est pas une boucle mais juste un pas de plus.

En passant ca evite a une application de prendre 100/100 de l'UC (ce qui va se passer dans ton cas avec ta boucle). Et je viens de voir que mon premier exemple ne marchera pas car tant qu'il n'y aucun message a passer cette partie n'est pas traité.
Sinon y a le timer aussi pour eviter la boucle.

Mais euh SnOOpss, tu as lu son post ? Il s'en fou du timer, ce qu'il veut c'est une fonction qu'il peut interrompre. Ta première proposition, c'est crados comme truc et meme irréalisable. Ca marchera si t'as un pti programme a deux balles a faire.

Un petit  programme a 2 balles ?
La technique ne viens pas de moi, et elle est souvent utilisé dans les applications gourmandes en UC justement comme les jeux pour eviter de tout bloquer (la deuxieme methode, la premiere me suis chié) et perso meme un debutant peut l'appliquer avec les bases, tandis que les threads c'est pas dit qu'il connaisse.

Je ne connait pas sa boucle mais c'est egalement possible avec un timer, c'est la maniere la plus crade que je connais mais ca marche.
tu lances un timer et tu traites
WM_TIMER: { maboucle(); }

Le meilleur moyen d'avoir une fonction qu'on peut pas interrompre c'est de ne pas faire une fonction bloquante. J'ai toujours vu que c'etait a eviter comme la peste.

Evidement la fonction maboucle() n'est PAS une boucle mais a chaque appel elle avance d'un pas.

Sinon teste ca, mais je te conseille plutot d'eviter une boucle bloquante trop longue.

void DoEventsCpp(void)
{
MSG msg;
while(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

Mais cette astuce, ca marche pour un programme complètement figé, c'est totalement anti évolutif a mon gout. On peut pas savoir les besoins futurs du programme. On va pas créer une fonction pour chaque nouvelle tache lourde que l'on doit effectuer.