IMPORTANT ET URGENT. MERCI D'AVANCE

Bonjour, mon amie a un projet console d'horloge + réveil à faire pour ses cours en c++. Je ne programme pas moi-même en c++ mais j'en profite parce qu'elle ne peut demander d'aide (pas internet !!!). Je programme en VB donc je suis un peu pommer pour l'aider. Je résume ce que doit faire le programme (en français) et ce qui merde...

En résumé (l'essentiel) :
- Module Clavier : scruter le clavier pour détecter quelle touche est appuyée ('m', 'M', '+', '-') (1 fonction "scruterClavier()")

- Module Cadran : affichage des données restituées (1 fonction "afficherCadran()")

- Module Horloge : (fonctions "Controler()", "AvancerHeures", "ReculerHeures", "AvancerMinutes",... )
    - n modes changeant selon le nombre de fois qu'on appuie sur la touche 'm'
        1 - affichage de l'heure (Buuuuuuuuupppp !!!) (120 boucles de "Sleep(500)")
        2 - réglage des heures avec les touches '+' et '-' (OK)
        3 - réglage des minutes avec les touches '+' et '-' (OK)
        4 - réglage du réveil (appel de "reveil::controler(...)") (OK)
        1 - etc...

- Module Réveil : (fonctions "Controler()", "AvancerHeuresAlarme", "ReculerHeuresAlarme", "AvancerMinutesAlarme",... )
    - n modes changeant selon le nombre de fois qu'on appuie sur la touche 'm'
        1 - réglage des heuresAlarme avec les touches '+' et '-' (OK)
        2 - réglage des minutesAlarme avec les touches '+' et '-' (OK)
        3 - affichage de l'heure Alarme (OK)
        4 - retour à l'affichage de l'heure normale (normalement, appel  de "horloge::controler()") (Buuuuuuuuupppp !!!)

Voilà ce qui cloche :

1- Lors de l'affichage de l'heure, qui doit s'incrémenter toutes les minutes, si on utilise un "Sleep(60000)" dans "Horloge::Controler()",  le programme bug et on ne peut plus se balader dans les modes. D'où l'utilisation d'un "Sleep(500)" avec 120 boucles. Pas beau mais ça  marche. Y a-t-il plus simple ?

2- Lorsqu'on arrive au réglage de l'alarme, plus moyen de retourner vers "Horloge::controler()". Pourquoi ? Comment faire ?

3- Si quelqu'un voit toujours de quoi je parle, lorsque qu'on passe de "Horloge::controler()" qui gère l'écoulement du temps avec "Sleep()" vers "Reveil::Controler()", l'horloge continue-t-elle de tourner ? Pas moyen de vérifier car ça bug (cf. point 2)... (Je connais pas c++ mais y a-t-il moyen de faire tourner 2 fonctions simultanément ? Comment ?)

Pour plus de précision ou avoir morceaux de code pour vérifier, ne pas hésiter à demander. Merci d'avance de l'aide que vous nous apporterez.
Merci.......

le code pourait etre interessant. je regrderai

Il peut utiliser des threads ou des timers pour faire ça.

Avec les timers, le programme recevra un événement toutes les X millisecondes, et restera réactif. Par contre, ça demande de faire une boucle de messages dans le programme.

Sinon, tu crée un thread qui gère l'input, et un qui incrémente ta variable toutes les X millisecondes (en faisant Sleep).

Regarde dans la MSDN pour les fonctions sur les timers ou les threads.

---

Sachant qu'on peut toujours enlever une ligne à un programme, et que dans un programme il y a toujours un bug, un programme peut se résumer à une ligne avec un bug.

Salut, comme j'ai cru le voir les Threads tournent en parallèle ce qui pourrait faire tourner l'horloge indépamment du reste du programme. Peux-t-on l'arrêter et le redémarrer en cours d'exécution programme ?

Aurais-tu un exemple concrêt simple d'utilisation et de codage ?

Merci.
Des bouts de code seront fournis incessamment sous peu...

code de la classe horloge
#include "horloge.h" // class's header file

// class constructor
Horloge::Horloge(short _heures, short _minutes, short _mode, short _nbMode,
                       short _resolution, Clavier _clavier, Cadran _cadran):
heures(_heures),
minutes(_minutes),
mode(_mode),
nbMode(_nbMode),
resolution(_resolution),
clavier(_clavier),
cadran(_cadran)
{
    // insert your code here
}

// class destructor
Horloge::~Horloge()
{
    // insert your code here
}

void Horloge::AvancerHeures()
{
 if (resolution == 12 && heures < 11)
 {
  ++heures;
 }
 else if (resolution == 12 && heures == 11)     
      {                                         
       heures = 00;
      }
      else if (resolution == 24 && heures < 23)
           {
            ++heures;
           }
           else if (resolution == 24 && heures == 23)
                {
                 heures = 00;
                }    
}

void Horloge::AvancerMinutes()
{
 if (minutes < 59)
 {
  ++minutes;
 }
 else if (minutes == 59)
      {
       minutes = 00;
      }    
}

void Horloge::ReculerHeures()
{
 if (resolution == 12 && heures > 00)
 {
  --heures;
 }
 else if (resolution == 12 && heures == 00)     // à 12h du matin passe à 11h
      {                                         // à 00h du soir passe à 11h
       heures = 11;
      }
      else if (resolution == 24 && heures > 00)
           {
            --heures;
           }
           else if (resolution == 24 && heures == 00)
                {
                 heures = 23;
                }    
}

void Horloge::ReculerMinutes()
{
 if (minutes > 00)
 {
  --minutes;
 }
 else if (minutes == 00)
      {
       minutes = 59;
      }        
}

void Horloge::Controler()
{
 Clavier unClavier;
 Cadran unCadran;
 unCadran.Afficher(":",5);
 unCadran.Afficher(heures,2);
 unCadran.Afficher(minutes,7);
 short compteur = 0;
 do
         {
          Sleep(250);
          ++compteur;
          if (compteur == 240)
          {
           AvancerMinutes();
           unCadran.Afficher(minutes,7);
           compteur = 0;
          }
          if (minutes == 00 && compteur == 0)
          {
           AvancerHeures();
           unCadran.Afficher(heures,2);
           
          }
         } while (!unClavier.ScruterClavier());
 char touche;
 int modulo;
 do
 {
  touche = unClavier.ScruterClavier();
  if (touche == 3)
  {
   modulo = mode % nbMode;
   switch(modulo)
   {
    case 1 :
         unCadran.Afficher("HH : ",2);
         unCadran.Afficher(heures,7);
         break;
    case 2 :
         unCadran.Afficher("MM : ",2);
         unCadran.Afficher(minutes,7);
         break;
    case 0 :
         unCadran.Afficher(heures,2);
         unCadran.Afficher(minutes,7);
         short compteur2 = 0;
         do
         {
          Sleep(250);
          ++compteur2;
          if (compteur2 == 240)
          {
           AvancerMinutes();
           unCadran.Afficher(minutes,7);
           compteur2 = 0;
          }
          if (minutes == 00 && compteur2 == 0)
          {
           AvancerHeures();
           unCadran.Afficher(heures,2);
           
          }
         } while (!unClavier.ScruterClavier());
         break;
   }
   ++mode;
  }
  else if (touche == 1)
       {
       switch (modulo)
         {
          case 1 :
               AvancerHeures();
               unCadran.Afficher(heures,7);
               break;
          case 2 :
               AvancerMinutes();
               unCadran.Afficher(minutes,7);
               break;
         }           
       }
       else if (touche == 2)
            {
            switch (modulo)
                   {
                   case 1 :
                        ReculerHeures();
                        unCadran.Afficher(heures,7);
                        break;
                   case 2 :
                        ReculerMinutes();
                        unCadran.Afficher(minutes,7);
                        break;
                   }            
            }
 } while(touche != 4);
}

code de la classe Reveil
#include <windows.h>

#include "reveil.h" // class's header file

// class constructor
Reveil::Reveil(short _heures, short _minutes, short _mode, short _nbMode,
                     short _resolution, Clavier _clavier, Cadran _cadran,
                     short _heureAlarme, short _minuteAlarme):                    
Horloge(_heures, _minutes, _mode, _nbMode, _resolution, _clavier, _cadran),
heureAlarme(_heureAlarme),
minuteAlarme(_minuteAlarme)
{
    etatAlarme = false;
}

// class destructor
Reveil::~Reveil()
{
    // insert your code here
}

void Reveil::AvancerHeuresReveil()
{
 if (resolution == 12 && heureAlarme < 11)
 {
  ++heureAlarme;
 }
 else if (resolution == 12 && heureAlarme == 11)     
      {                                         
       heureAlarme = 00;
      }
      else if (resolution == 24 && heureAlarme < 23)
           {
            ++heureAlarme;
           }
           else if (resolution == 24 && heureAlarme == 23)
                {
                 heureAlarme = 00;
                }    
}

void Reveil::AvancerMinutesReveil()
{
 if (minuteAlarme < 59)
 {
  ++minuteAlarme;
 }
 else if (minuteAlarme == 59)
      {
       minuteAlarme = 00;
      }    
}

void Reveil::ReculerHeuresReveil()
{
 if (resolution == 12 && heureAlarme > 00)
 {
  --heureAlarme;
 }
 else if (resolution == 12 && heureAlarme == 00)
      {            
       heureAlarme = 11;
      }
      else if (resolution == 24 && heureAlarme > 00)
           {
            --heureAlarme;
           }
           else if (resolution == 24 && heureAlarme == 00)
                {
                 heureAlarme = 23;
                }    
}

void Reveil::ReculerMinutesReveil()
{
 if (minuteAlarme > 00)
 {
  --minuteAlarme;
 }
 else if (minuteAlarme == 00)
      {
       minuteAlarme = 59;
      }        
}

void Reveil::Controler()
{
 Clavier unClavier;
 Cadran unCadran;
 unCadran.Afficher(":",5);
 unCadran.Afficher(heureAlarme,2);
 unCadran.Afficher(minuteAlarme,7);
 char touche;
 int modulo2;
 do
 {
  touche = unClavier.ScruterClavier();
  if (touche == 3)
  {
   modulo2 = mode % nbMode;
   switch(modulo2)
   {
    case 1 :
         unCadran.Afficher("HHr: ",2);
         unCadran.Afficher(heureAlarme,7);
         break;
    case 2 :
         unCadran.Afficher("MMr: ",2);
         unCadran.Afficher(minuteAlarme,7);
         break;
    case 3 :
         unCadran.Afficher("Rev: ",2);
         unCadran.Afficher("Of",7);
         break;
    case 4 :
         unCadran.Afficher(heureAlarme,2);
         unCadran.Afficher(minuteAlarme,7);
         break;
    case 0 :
         if (etatAlarme == true)
            unCadran.Afficher("R",9);
         if (etatAlarme == false)
            unCadran.Afficher(" ",9);
         unCadran.Afficher(heures,2);
         unCadran.Afficher(minutes,7);  
         //Controler();
         break;
   }
   ++mode;
  }
  else if (touche == 1)
       {
       switch (modulo2)
         {
          case 1 :
               AvancerHeuresReveil();
               unCadran.Afficher(heureAlarme,7);
               break;
          case 2 :
               AvancerMinutesReveil();
               unCadran.Afficher(minuteAlarme,7);
               break;
          case 3 :
               if (etatAlarme == false)
               {
                  etatAlarme = true;
                  unCadran.Afficher("Rev: ",2);
                  unCadran.Afficher("On",7);
               }
               else if (etatAlarme = true)
                    {
                       etatAlarme = false;
                       unCadran.Afficher("Rev: ",2);
                       unCadran.Afficher("Of",7);
                    }
         }           
       }
       else if (touche == 2)
            {
            switch (modulo2)
                   {
                   case 1 :
                        ReculerHeuresReveil();
                        unCadran.Afficher(heureAlarme,7);
                        break;
                   case 2 :
                        ReculerMinutesReveil();
                        unCadran.Afficher(minuteAlarme,7);
                        break;
                   case 3 :
                        if (etatAlarme == false)
                        {
                         etatAlarme = true;
                         unCadran.Afficher("Rev: ",2);
                         unCadran.Afficher("On",7);
                        }
                        else if (etatAlarme = true)
                             {
                              etatAlarme = false;
                              unCadran.Afficher("Rev: ",2);
                              unCadran.Afficher("Of",7);
                             }     
                   }            
            }
 } while(touche != 4);
   
}

/*void Reveil::SurveillerAlarme()
{
    Sleep(60000);
    if (heures == heureAlarme && minutes == minuteAlarme && etatAlarme == true)
   {
    do
    {
     Beep(1000,2000);  // 1000 hertz (C5) for 2000 milliseconds  
    }while (minutes != (minutes + 5));
   }
}*/

Pour redémarrer ou stopper ton thread, utilise une variable globale que tu mettra à true ou false selon l'etat que tu veut mettre à ton thread (en marche ou en pause). Ton thread vérifiera l'etat de cette variable, et se stoppera ou se remettra en route selon cet etat.

---

Sachant qu'on peut toujours enlever une ligne à un programme, et que dans un programme il y a toujours un bug, un programme peut se résumer à une ligne avec un bug.