0

我有一个实现相同接口的任务向量。我有一个可以有多个任务的状态机对象，我有一大堆事件。如果调用了特定事件，我希望该事件调用“ProcessTasks”的函数，其中 ProcessTasks 采用需要调用的特定接口函数，并为每个任务调用该函数。我想避免在每个事件函数中使用巨大的 case 语句或重复 for 循环迭代，但我不知道该怎么做。是否有允许我这样做的构造/方法，或者 case 语句方法是最好的方法，还是最好在每个函数中折腾循环？

谢谢 ： ）

示例示例（我的状态模式 sm 中的单个状态类）：

State_e StateIdle::EVENT_REQUEST_STOP_()
{
    ProcessTasks( HandleStopFn );
    return STATE_STOPPED;
}

// -- more events

/* desired solution allows me to have to implement
   the loop only once, but be able to call any of
   the functions in the interface, for any number of events */

    for( vector<TaskPtr>::iterator it = m_tasks.begin(); it != m_tasks.end(); ++it )
    {
        it->HandlerFunction()
    }

//TaskPtr 是 boost auto ptr 并实现了这个缩短的接口

class Task
{
    void HandleActiveFn() = 0;
    void HandleStopFn() = 0;
};
4

2 回答 2

2

您可以将函数绑定到std::function，然后遍历向量（或使用std::for_each）调用函数并将指向每个元素的指针作为第一个参数传递。例如，这是绑定成员函数并在类型实例上调用它们的方法：

#include <functional>
#include <iostream>
#include <vector>
#include <algorithm>

struct IFoo 
{
  virtual void foo1() const = 0;
  virtual void foo2() const = 0;
};

struct Foo : public IFoo
{

  virtual void foo1() const {
    std::cout << "Foo::foo1\n";
  }
  virtual void foo2() const {
    std::cout << "Foo::foo2\n";
  }
};

int main() {

  std::function <void(IFoo*)> f1 = &IFoo::foo1;
  std::function <void(IFoo*)> f2 = &IFoo::foo2;

  std::vector<IFoo*> foos{new Foo(), new Foo(), new Foo()};

  std::for_each(foos.begin(), foos.end(), f1);

  std::for_each(foos.begin(), foos.end(), f2);

}

如果您按值存储元素，而不是指针，则可以使用std::mem_fn：

auto f1 = std::mem_fn(&Foo::foo1);
auto f2 = std::mem_fn(&Foo::foo2);

std::list<Foo> foos = ....;

std::for_each(foos2.begin(), foos2.end(), f1);
于 2012-08-21T14:37:42.757 回答
1

提供一个接受private成员函数指针的成员函数，并用于在每个实例上调用成员函数：StateIdleTaskstd::for_eachTask

void _invoker(void (Task::*fun)())
{
    std::for_each(m_tasks.begin(),
                  m_tasks.end(),
                  [&](TaskPtr a_t) { (a_t->*fun)(); });
}

请参阅演示http://ideone.com/A4c5U。

如果你想避免 a switch，你可以使用 a 构造一个函数表std::map：

std::map<std::string, void (Task::*)()> function_table;
function_table["ACTIVE"] = &Task::HandleActiveFn;
function_table["STOP"]   = &Task::HandleStopFn;

void _invoker(const std::string& a_name)
{
    auto function_entry = function_table.find(a_name);
    if (function_table.end() != function_entry)
    {
        std::for_each(m_tasks.begin(),
                      m_tasks.end(),
                      [&](TaskPtr a_t)
                      {
                          (a_t->*(function_entry->second))(); 
                      });
    }
}

并致电：

_invoker("STOP");
_invoker("ACTIVE");

您可能更喜欢：

_invoker(&Task::HandleStopFn);
_invoker(&Task::HandleActiveFn);
于 2012-08-21T14:54:19.193 回答