需要某种方法将函数存储在列表中，然后调用它们

Question

这个列表必须包含函数，它们可能来自不同的命名空间，甚至是实例化类的方法。
然后将迭代该列表并调用所有函数和方法。如果它们也可以包含参数，那就太好了。

我正在考虑使用 std::vector，但我怀疑我的猜测远不正确。

您推荐我什么方法？欢迎所有帮助。

Answer 1

如果您的编译器已经支持 std::function 和 std::bind ，您可以使用它。

#include <functional>
#include <vector>

void x(int) {}
void y() {}
class Z {
public:
    void z() {}
};

int main(int argc, char *argv[])
{
    typedef std::function<void ()> VoidFunc;
    typedef std::vector<VoidFunc> FuncVector;
    FuncVector functions;

    functions.push_back(std::bind(&x, 1));
    functions.push_back(&y);
    Z z1;
    functions.push_back(std::bind(&Z::z, z1));

    for(FuncVector::iterator i = functions.begin(); i != functions.end(); i++) {
        (*i)();
    }

    return 0;
}

Answer 2

让所有函数都实现 命令模式。

当您

std::list<Command>

迭代列表中，您调用每个列表项的 Execute() 方法。

例如，假设您有一个名为 Commander 的简单命令界面：

class Commander
{
public:
    virtual        ~Commander;

    virtual void    Execute();//= 0;
};

并且您想要将三个对象放入列表中：灰狗、灰隼和女朋友。将每个对象包装在调用该对象感兴趣的函数的 Commander 对象中。灰狗奔跑：

class RunGreyhound: public Commander
{
public:
    void            Execute()
                    {
                        mGreyhound->Run();
                    }
private:
    Greyhound*      mGreyhound;
};

灰隼飞翔：

class RunGyrefalcon: public Commander
{
public:
    void            Execute()
                    {
                        mGyrefalcon->Fly( mGyrefalcon->Prey() );
                    }    
private:
    Gyrefalcon*      mGyrefalcon;
};

女朋友尖叫：

class RunGirlfriend: public Commander
{
public:
    void            Execute()
                    {
                        mGirlfriend->Squawk( mGirlfriend->MyJunk(), mGirlfriend->Mytrun() );
                    }
private:
    Girlfriend*     mGirlfriend;
};

将指挥官对象填入您的列表中。现在您可以迭代它们并调用每个元素的 Execute() 方法：

std::list<Commander> cmdlist;

RunGreyhound dog;
cmdlist.push_back( dog );

RunGyrefalcon bird;
cmdlist.push_back( bird );

RunGirlfriend gurl;
cmdlist.push_back( gurl );

for ( std::list<Commander>::iterator rit = cmdlist.begin(); rit != cmdlist.end(); ++rit )
{
    rit->Execute();
}

Answer 3

如果您不想使用现有的解决方案（例如 boost::function），则需要创建一个表示函数的基类，然后创建包装各种函数源的派生类。例如：

#include <iostream>
#include <list>
using std::cout;
using std::list;

struct Function {
  virtual ~Function() { }
  virtual void operator()() = 0;
};

struct PlainFunction : Function {
  PlainFunction(void (*function_ptr_arg)()) : function_ptr(function_ptr_arg) { }
  virtual void operator()() { (*function_ptr)(); }
  void (*function_ptr)();
};

template <typename T> 
struct MethodFunction : Function {
  MethodFunction(T &obj_arg,void (T::*method_ptr_arg)())
    : obj(obj_arg), method_ptr(method_ptr_arg)
  {
  }
  virtual void operator()() { (obj.*method_ptr)(); }
  T &obj;
  void (T::*method_ptr)();
};

void f()
{
  cout << "Called f()\n";
}

struct A {
  void f() { cout << "Called A::f()\n"; }
};

int main(int argc,char **argv)
{
  list<Function *> functions;
  functions.push_back(new PlainFunction(f));
  A a;
  functions.push_back(new MethodFunction<A>(a,&A::f));
  list<Function *>::iterator i = functions.begin();
  for (;i!=functions.end();++i) {
    (*(*i))();
  }
  while (!functions.empty()) {
    Function *last_ptr = functions.back();
    functions.pop_back();
    delete last_ptr;
  }
}