c++ - C++中指向函数对象的指针

Question

我想将一个函数对象传递给一个类，类将使用该函数对象在类内部做一些工作。

但问题是，我不知道函数对象将被传入什么。所以我想，在类中定义一个 void * 指针，这个指针将被初始化将传入的函数对象。

代码如下:

class A 
{
    public:
        //...
        void doSomeJob(int x)
        {
            (*functor)(x); //use the function object to process data x
        }

    private:
        //...
        void *functor; //function object's pointer will be assigned to this pointer
};

但是代码不起作用。我想，不能那样使用 void *functor。

我知道我可以使用模板类来完成这项工作，但我的问题是，我仍然可以使用指向函数对象的指针来完成这项工作吗？如何做？

附言

为了让我的问题更清楚，可能有几个函数对象，它们在处理数据的方式上彼此不同，我不知道将传入什么函数对象，但我知道它们中的每一个都需要一个 int 参数。

正如一些答案所说，我可以通过函数指针来完成这项工作，但是函数对象比函数指针有更多的实用性，比如states，这就是我我会用的。

Answer 1

如果函数对象的类型未存储在调用机制可访问的某处，则您无法在调用站点调用您未知类型的函数对象。

有两种选择:

如果你可以使用 C++11 或 boost，你可以使用 std::function resp。 boost::function:

class A
{
public:
  // ...
  void doSomeJob(int x)
  {
    functor(x);
  }
private:
  std::function<void(int)> functor; // or boost::function when using boost
};

此处类型存储(以隐式形式)在 function 模板的机制中。

否则，如果您可以要求所有传递的函数对象都具有派生自特定基类的类类型，则可以创建一个抽象基类:

struct AbstractFunctor
{
  virtual void operator()(int) = 0;
};

class A
{
public:
  // ...
  void doSomeJob(int x)
  {
    (*functor)(x);
  }
private:
  AbstractFunctor* functor; // or boost::function when using boost
};

此处类型存储在函数对象的虚拟表中。

如果实在不会boost，也可以自己写一个类似的方案。关键词是“类型删除”，它基本上是通过从已知的基类(如我的第二个解决方案)动态生成派生对象来工作的，该基类知道您的对象的类型并可以调用它。它可能大致如下完成(未经测试的代码):

class int_function
{
private:
  struct abstract_forward
  {
    virtual void call(int) = 0;
    virtual abstract_forward clone() const = 0;
    virtual ~abstract_forward() {}
  };
  template<typename Functor> struct forward: abstract_forward
  {
    forward(Functor f): func(f) {}
    void call(int i) { func(i); }
    abstract_forward clone() const { return new forward<Functor>(func); }
    Functor func;
  };
public:
  template<typename Functor> int_function(Functor f)
  {
    forwarder = new forward<Functor>(f);
  }
  int_function(int_function const& other)
  {
    forwarder = other.forwarder->clone();
  }
  int_function& operator=(int_function const& other)
  {
    abstract_forward* newfwd = other.forwarder->clone();
    delete forwarder;
    forwarder = newfwd;
  }
  ~int_function()
  {
    delete forwarder}
  }
  void operator()(int i)
  {
    forwarder->call(i);
  }
private:
  abstract_forward* forwarder;
};

class A
{
public:
  void doSomeJob(int x)
  {
    functor(x);
  }
private:
  int_function functor;
};