C ++中的回调计时器功能

Question

我正在尝试在C ++中实现一个回调计时器函数，该函数应该在超时后执行回调。 我正在侦听套接字，然后在其上等待消息。 因此，如果我有类似getMessages（）的东西，并且想在其中传递计时器函数作为参数。 因此，如何实现在收到消息后启动计时器，如果在下一条消息到达之前存在超时，则会发生回调。

我是回调函数的新手。 任何帮助是极大的赞赏。 谢谢！

Answer 1

您可能知道，但是C ++中没有诸如回调函数之类的东西。 但是，有函数指针 。

函数指针实际上就是-函数指针。 使用“普通”指针，您可以指定指针指向的数据类型（例如， int *foo ， char *bar ...）； 函数指针的工作方式相似，因为您指定了函数的签名： void (*baz)(int) 。 注意，在这种情况下， baz是指针的名称。

没有代码，我不确定您的计时系统如何工作。 首先想到的是滴答功能，它会被反复调用。 您可以定期调用此函数，也可以测量函数调用之间的时间-无论哪种情况，您都知道已经过去了。 递增（或递减）分配的时间变量，并在时间到时使用功能指针触发“回调”。

您可能会发现有用的一件事是typedef荷兰国际集团的回调函数，像这样： typedef void (*Callback)(int)再次， Callback是标识符）。 然后，您可以定义一个函数，就像其他成员一样（ Callback func = foo ）并调用它（ func(12) ）。

PS：在SE周围点缀的函数指针有很多资源。 这是一个

Answer 2

    Here is one approach that I would suggest. You will require 3 different threads for this:

 1. First thread is the main processing thread (Th1). It waits for two separate events - either "data on socket" event or "timeout event"
 2. Second thread (Th2) will constantly listen on socket ( stay blocked on socket either through select or read call ) and when data appears it will read the data, wrap the data in an event and post it to the first thread.
 3. The third thread (Th3) will implement the timer functionality. It will wake up after every 'N' seconds ( where 'N'is timeout interval ) and once it wakes up it will create a timeout event and post it to first thread.

    A skeleton of the code would look something like this:

    Class Processor
    {
      public:
        // std::list<ProcessorEventBase* > eventQueue;
        void init ()
        {
            // 1. initialize SocketListener and pass address of 'Processor::recvDataOnSocket' function
            // 2. initialize TimerUtil and pass address of 'Processor::timeOut' function
            // 3. create and run Processor ( Th1 ) thread
            // 4. keep the thread waiting on a condition variable
            // 5. When thread wakes up, let it fetch event from queue and process it.
        }

        static void recvDataOnSocket ( char* data, int datalen, void* arg )
        {
           // typecast arg to Processor
           // create a data on socket event
           // post it to the 'eventQueue'
           // signal the waiting thread
        }

        static void timeOut ( void* arg )
        {
            // typecast arg to Processor
            // create a timeout event
            // post it to event queue
            // signal the waiting thread
        }    
    }

    class SocketListener
    {
       public:
          void init ( SocketCallback socketCallback)
           {
               // store the socket Callback
               // create a thread to listen on socket ( Th2 )
               // when data arrives, call the callback i.e. socketCallback and 
               // pass data pointer and its size and the stored arguement
           }
    }

    class TimerUtil
    {
       public:
          void init ( TimeoutCallback timeoutCallback, void* arg )
           {
               // store the timeout Callback
               // create a thread that wakes up every 'N' seconds ( Th3 )
               // when timer expires, call the callback i.e. timeoutCallback and 
               // pass the stored argument i.e. arg
           }
    }

Callback would be something like this:

    typedef void (*SocketCallback ) ( char* data, int datalen, void* arg);
    typedef void (*TimeoutCallback ) ( void* arg );