Question

我有一个实现相同界面的任务向量。我有一个状态机对象，可以有多个任务，我有一大堆事件。如果调用了一个特定的事件，我希望事件调用一个函数“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;
};

Answer 1

您可以将函数绑定到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);

Answer 2

在private中提供StateIdle成员函数，该函数接受Task成员函数指针，并使用std::for_each调用每个Task上的成员函数实例：

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

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

如果您想避免switch，可以使用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);

使用对象向量调用接口函数的Clean方法

2 个答案: