Question

我已经阅读了关于SO的各种答案，但仍然没有理解在这种情况下如何使对象方法可以调用：

考虑到：

     Class A
{
       void generator(void)
       {
            int i = 1;
            while(1)
            {
                if(i == 1)
                {
                    one(/***/);//Should be a flag 
                    i = 2;
                }
                else
                {
                     two(/**/);//Should be a flag 
                     i = 1;
                }
          }
      }
      template <typename CallbackFunction>
      void one(CallbackFunction&& func)
      {

      }
      template <typename CallbackFunction>
      void two(CallbackFunction&& func)
      {

      }

      A()
      {
          std::thread t(&A::generator, this);
          t.detach();
      }
};

和一个简单的主文件：

void pOne(/**/)
{
    std::cout<<"1"<<std::endl;
}

void pTwo(/**/)
{
    std::cout<<"2"<<std::endl;
}

 A myA;
 A.One(pOne);
 A.Two(pTwo);

int main(int argc, char** argv)
{

   while(1){}

}

以下是我所在的地方：

generator（）应该更新一个标志，并且一个（）＆amp;两个（）应该在该标志上进行轮询＆amp;永远循环。

One（）（两个（）也）应该有一个函数指针作为参数，如果需要其他参数，pOne（）应该有除函数指针之外的相同参数。

所以我的问题是：

1）我的理解是否正确？

2）有没有一种干净的方法让generator（）启动一个（）或两个（）？（标志，信号量，互斥量或任何标准方法）

3）假设代码正常工作，它是否符合我的预期？即打印1和2？

如果重要，请访问ubuntu

Answer 1

免责声明1：与其他人一样，我将问题解释为：

- ＆GT;你需要一个事件处理程序

- ＆GT;你想要那些事件的回调方法

我认为这是因为我之前在i2c处理程序序列上帮助过你的唯一原因。

此外，还有比这更好的逻辑，它遵循你的存根“规则”。

您提到您使用的是Ubuntu，因此您将缺少Windows事件系统。

免责声明2：

1-为了避免深入，我将使用一种简单的方法来处理事件。

2-代码未经测试＆amp;仅提供逻辑

class Handler
{

private:

    std::mutex event_one;
    event_one.lock();

    void stubEventGenerator(void)
    {
        for(;;)
        {
            if(!event_one.try_lock())
            {
                event_one.unlock();
            }

            sleep(15); //you had a sleep so I added one
        }
    }

    template <typename CallbackFunction>
    void One__(CallbackFunction && func)
    {
        while(1)
        {
            event_one.lock();
            func();

        }
    }
public:

    Handler()
    {
        std::thread H(&Handler::stubEventGenerator, this);
    }

    ~Handler()
    {
        //clean threads, etc
        //this should really have a quit handler
    }

    template <typename CallbackFunction>
    void One(CallbackFunction && func) //I think you have it right, still I'm not 100% sure
    {
        std::thread One_thread(&Handler::One__, this, func); //same here
    }


};

有些观点：

One（）作为调用One __（）的线程的包装器，如果你想要它是非阻塞的。

互斥体可以是一种处理事件的简单方法，只要在上一次事件发生期间不会发生相同的事件（您可以自由地使用更好/更合适的工具用于您的用例，或者使用boost :: 仅在必要时

One（）＆amp;的原型一个__（）可能是错的，这是你的一些研究。

最后：它如何运作：

只要无法锁定互斥锁，

std :: mutex.lock（）就会阻塞，因此只要你的事件生成器无法解锁它，One__就会等待。

一旦解锁，One__将执行你的std :: function＆amp;等待事件（互斥）再次被提升（解锁）。

远非一个完美的答案，但缺乏时间，而且无法将其放在评论中让我发布，将在稍后编辑

Answer 2

根据您提供的有限信息，可以通过以下方式编制此代码：

#include <iostream>
#include <thread>
typedef void(*fptr)();
void pOne(/**/)
{
    std::cout<<"1"<<std::endl;
}

void pTwo(/**/)
{
    std::cout<<"2"<<std::endl;
}
class A
{
    public:
       void generator(void)
       {
            int i = 1;
            while(1)
            {
                if(i == 1)
                {
                    fptr func = pOne;
                    one(func);//Should be a flag 
                    i = 2;
                }
                else
                {
                     fptr func = pTwo;
                     two(func);//Should be a flag 
                     i = 1;
                }
          }
      }
      template <typename CallbackFunction>
      void one(CallbackFunction&& func)
      {
         func();
      }
      template <typename CallbackFunction>
      void two(CallbackFunction&& func)
      {
        func();
      }

      A()
      {
          std::thread t(&A::generator, this);
          t.detach();
      }
};
int main()
{
  A myA;
  while(1)
  {
  }
  return 0;
}

如果你想要一个和两个接受任何类型/数量的参数然后将第二个参数作为可变参数模板传递。我也无法理解你为什么要从main调用一个和两个，因为你的生成器函数就是为了这个目的only，这个生成器函数是从在类构造函数

中分离的线程调用的

可调用函数C ++

2 个答案: