Équivalent à window.setTimeout () pour C ++

En javascript, il y a cette fonction très douce window.setTimeout( func, 1000 ) ; qui invoquera asynchrone func après 1000 ms.

Je veux faire quelque chose de similaire en C ++ ( sans multithreading ), alors j’ai mis en place un exemple de boucle comme:

     #include 

     struct callback
     {
       // Le _time_ cette fonction sera exécutée.
       double execTime;

       // La fonction à exécuter après que execTime soit passé
       void * func;
     };

     // Exemple de fonction à exécuter
     void go ()
     {
       met ("GO");
     }

     // Sens global du temps à l'échelle du programme
     temps double ;

     int main()
     {
       // démarre le chronomètre
       temps = 0;

       // Faire un exemple de rappel
       Rappel c1;
       c1.execTime = 10000;
       c1.func = go;

       tandis que (1)
       {
         // il est temps de l'exécuter
         si (heure> c1.execTime)
         {
           c1.func;  // !!  ne fonctionne pas!
         }

         time ++;
       }
     }

Comment puis-je faire quelque chose comme ça?

Make Callback::func de type void (*)() , c’est-à-dire

 struct Callback { double execTime; void (*func)(); };

Vous pouvez appeler la fonction de cette façon:

 c1.func();

Aussi, ne vous inquiétez pas, attendez. Utilisez ualarm sous Linux ou CreateWaitableTimer sous Windows.

Après la sortie de C ++ 11, et si vous utilisez un compilateur pris en charge par c ++ 11, vous pouvez utiliser lambda , une fonction de modèle variadique et un thread asynchrone pour simuler facilement la fonction javascript dans c ++.

Voici le code que j’ai écrit pour setTimeOut, il est entièrement testé:

Définition de la fonction setTimeOut:

  #include //different header file in linux #include  using namespace std; template  void setTimeOut(int milliseconds,std::function func,ParamTypes... parames) { std::async(std::launch::async,[=]() { Sleep(milliseconds); func(parames...); }); };

Cette fonction accepte les arguments variables en utilisant le modèle variadique de c + 11. Le code peut vous montrer comment l’utiliser:

  #include  #include  #include  #include  #include  #include  using namespace std; int main() { std::mutex locker; std::function func1 = [&]() { std::unique_lock lk(locker); std::cout << "func 1 is trigged:" << " no parameter" << std::endl; lk.unlock(); }; std::function func2 = [&](int param) { std::unique_lock lk(locker); std::cout << "func 2 is trigged:" << " int: " << param < func3 = [&](int param1,std::ssortingng param2) { std::unique_lock lk(locker); std::cout << "func 3 is trigged:" << " int: " << param1 << "; string: " << param2 << std::endl; lk.unlock(); }; for(int index=0;index<100;index++) { std::unique_lock lk1(locker); std::cout << "set timer for func 1" << std::endl; lk1.unlock(); setTimeOut<>(1000,func1); std::unique_lock lk2(locker); std::cout << "set timer for func 2" << std::endl; lk2.unlock(); setTimeOut(2000,func2,10000); std::unique_lock lk3(locker); std::cout << "set timer for func 3" << std::endl; lk3.unlock(); setTimeOut(5000,func3,10000,"ddddd"); } Sleep(10000000); }

En C ++, vous êtes plutôt limité. Vous avez besoin soit d’un système d’exploitation multithread, dans lequel vous pouvez utiliser une fonction de veille (le programme peut toujours continuer de fonctionner avec un thread séparé), soit d’un système de messagerie, tel que Windows.

La seule autre façon dont je vois que vous pouvez faire quelque chose consiste à disperser un grand nombre d’appels dans le code qui appelle une fonction renvoyant la valeur true ou false, selon que le temps s’est écoulé ou non. La fonction peut, bien sûr, être un rappel, mais vous devrez quand même l’appeler périodiquement.

Je ne fais que corriger votre code ici, sans penser en dehors de la boîte. Les autres réponses ont déjà donné des indications à cet égard.

Pour une meilleure sécurité de type, vous devez déclarer votre pointeur de rappel comme suit:

  // The function to execute after execTime has passed void (*func)() ;

Ensuite, appelez-le comme:

  c1.func() ;

Une autre (meilleure) réponse serait d’utiliser l’en-tête en C ++ et de déclarer la fonction comme suit:

 #include  function func ; // assign like func = go ; //go is a function name that accepts 0 parameters // and has return type void // exec like func() ;