Equivalente a janela.setTimeout() para C++

Question

Em javascript, não há este doce, doce de função window.setTimeout( func, 1000 ) ; o que vai de forma assíncrona invocar func depois de 1000 ms.

Eu quero fazer algo semelhante em C++ (sem multithreading), então eu coloquei um exemplo de loop como:

    #include <stdio.h>

    struct Callback
    {
      // The _time_ this function will be executed.
      double execTime ;

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

    // Sample function to execute
    void go()
    {
      puts( "GO" ) ;
    }

    // Global program-wide sense of time
    double time ;

    int main()
    {
      // start the timer
      time = 0 ;

      // Make a sample callback
      Callback c1 ;
      c1.execTime = 10000 ;
      c1.func = go ;

      while( 1 )
      {
        // its time to execute it
        if( time > c1.execTime )
        {
          c1.func ;// !!não funciona!
        }

        time++;
      }
    }

Como posso fazer algo como isso funciona?

Answer 1

Faço Callback::func do tipo void (*)(), ou seja

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

Você pode chamar a função desta maneira:

c1.func();

Além disso, não se preocupe. Usar ualarm no Linux ou CreateWaitableTimer nas janelas.

Answer 2

Depois de C++11, saiu, e se o seu estiver usando o c++11 suporte do compilador, você pode usar lambda, aridade variável função do modelo e thread assíncrono para simular a função javascript em c++ facilmente.

Aqui está o código que eu escrevi para setTimeOut, é totalmente testado:

setTimeOut funtion da definição:

    #include <windows.h>//different header file in linux
    #include <future>
    using namespace std;

    template <typename... ParamTypes>
    void setTimeOut(int milliseconds,std::function<void(ParamTypes...)> func,ParamTypes... parames)
    {   
        std::async(std::launch::async,[=]()
        {       
            Sleep(milliseconds);
            func(parames...); 
        });
     };

Esta função aceita variável de argumentos usando c+11 aridade variável de modelo, O código pode mostrar-lhe como usá-lo:

    #include <iostream>
    #include <thread>
    #include <string>
    #include <functional>
    #include <windows.h>

    #include <future>
    using namespace std;
    int main() 
    {
        std::mutex locker;
        std::function<void()> func1 = [&]()
        {
            std::unique_lock<std::mutex> lk(locker);
            std::cout << "func 1 is trigged:" << "   no parameter" << std::endl;
            lk.unlock();
        };      
        std::function<void(int)> func2 = [&](int param)
        {
            std::unique_lock<std::mutex> lk(locker);
            std::cout << "func 2 is trigged:" << "   int: " << param <<std::endl;
            lk.unlock();
        };
        std::function<void(int,std::string)> func3 = [&](int param1,std::string param2)
        {
            std::unique_lock<std::mutex> 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<std::mutex> lk1(locker);
            std::cout << "set timer for func  1" << std::endl;
            lk1.unlock();
            setTimeOut<>(1000,func1);

            std::unique_lock<std::mutex> lk2(locker);
            std::cout << "set timer for func  2" << std::endl;
            lk2.unlock();
            setTimeOut<int>(2000,func2,10000);

            std::unique_lock<std::mutex> lk3(locker);
            std::cout << "set timer for func  3" << std::endl;
            lk3.unlock();
            setTimeOut<int,std::string>(5000,func3,10000,"ddddd");
        }
        Sleep(10000000);
    }

Answer 3

Em C ++ por si só, você é bastante limitado. Você precisa de um sistema operacional multithread, onde possa usar uma função de sono (ainda pode ter o programa continuando com um thread separado) ou precisa de um sistema de mensagens, como o Windows.

A única outra maneira de vejo que você pode fazer algo é ter muitas chamadas espalhadas por todo o código que chama uma função que retorna verdadeira ou falsa, dependendo se o tempo foi decorrido. A função poderia, é claro, ser um retorno de chamada, mas você ainda precisaria chamá -lo periodicamente.

Answer 4

Estou apenas consertando seu código aqui, sem pensar fora da caixa. As outras respostas já deram algumas dicas para isso.

Para uma melhor segurança do tipo, você deve declarar seu ponteiro de retorno de chamada da seguinte forma:

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

Então, chame como:

  c1.func() ;

Answer 5

Outra resposta (melhor) seria usar o <functional> Cabeçalho em C ++ e declare a função como assim:

#include <functional>

function<void ()> func ;

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

// exec like
func() ;