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。

我知道我可以使用template class来完成这项工作，但我的问题是，我仍然可以使用pointer to function object来完成这项工作吗？

PS

为了使我的问题更清楚，可能有几个函数对象因处理数据的方式而彼此不同，我不会传递什么函数对象，但我知道每个函数对象都将采用{{ 1}}参数。

正如一些答案所说，我可以通过int完成工作，但是函数对象比函数指针有更多的实用工具，例如function pointer，这就是我要使用的东西。

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; };

Answer 2

void *functor; //function object's pointer will be assigned to this pointer

这不是函数指针。

你需要的是：

void (*functor)(int); //function pointer

更好的是（在C ++ 11中）：

#include <functional> //must include this 

std::function<void(int)> functor;

//then use it as:
functor(x);  //not (*functor)(x)

Answer 3

正确的语法是：

void (*functor)(int);

另请参阅本教程，了解有关声明和使用函数指针的更多信息：http://www.cprogramming.com/tutorial/function-pointers.html

Answer 4

C ++对其类型非常严格，因此您不能只使用void*作为函数指针。指针必须是一个实际的函数指针，供您调用。

你是什么意思，你不知道将传递什么功能对象？在该示例中，您知道它需要int或int&作为参数，并且可能返回void，例如，因此您可以将函数指针存储为：

void (*func)(int);

如果您的意思是说您希望能够存储类成员函数，或者重载operator()的类的实例，那么您可以使用std::function和std::bind来自<functional>如果你有C ++ 11，或boost::function和boost::bind：

boost::function<void (int)> func;

指向C ++中的函数对象

4 个答案: