0

同じインターフェイスを実装するタスクのベクトルがあります。複数のタスクを持つことができるステート マシン オブジェクトがあり、たくさんのイベントがあります。特定のイベントが呼び出された場合、ProcessTasks が呼び出される必要がある特定のインターフェイス関数を取得し、すべてのタスクに対してその関数を呼び出す「ProcessTasks」への関数を呼び出すイベントが必要です。すべてのイベント関数で巨大な case ステートメントを使用したり、for ループの反復を繰り返したりすることは避けたいのですが、その方法がわかりません。これを可能にする構成/アプローチはありますか、それともケースステートメントアプローチが最良の方法ですか、それとも各関数でループを投げるのが最善ですか?

ありがとう ： ）

サンプル例 (パターン化された 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 はブースト自動 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を参照してください。

を回避したい場合は、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);
于 2012-08-21T14:54:19.193 に答える