C++ 中的通用 Functor 类

Question

我试图在此处的线程之上构建： 可变长度模板参数列表？ 有一个默认的 Functor 类，这只是出于学术兴趣。我的目标是构建一个通用的 Fucntor 类：给定类名、方法名和参数类型（可变长度），它构建一个具有 operator() 方法的类，该方法采用模板 args 中指定的可变数量的参数类型和接受一个指针并应用给定的方法。想象一个类：

class MyClass
{
 public:
   float Fraction( float n, int m)
   {
       return n/m;
   }
   int Increment(int n)
   {
       return n+1;
   }
} ;

以及一个可以在任何函数中使用的模板化函子类：

int k = FunctorClass<MyClass, Increment, int, int /*return type*/> (3);
assert(k == 4);
float l = FunctorClass<MyClass, Fraction,  float, int, float, /*return type*/> (4,3);
assert(l == (4/3));

可以构造这样的函子类吗？ 旁注：不能使用 Variadic 模板，（在 VS2010 中构建，没有...模板参数） 感谢您的帮助

Answer 1

这当然是可行的，例如 Boost bind() 使用这种方法在幕后。但是，如果没有变量，您将无法获得完全的通用性，因为您将被限制为固定数量的模板参数，并且您需要为您想要支持的每个不同数量的参数键入实现。另外，如果没有右值引用，您将无法获得完美的转发。

也就是说，您尝试使用它的方式是行不通的：在声明成员函数时，您不能只命名它们。您需要使用例如 &MyClass::Increment 和 &MyClass::Fraction 来获取正确的成员函数点。如果成员函数重载，则需要消除它的歧义。

由于您显然希望启用此函数对象用于非静态成员函数，因此您还需要提供一个要调用该成员函数的对象。最合理的方法是将对象的引用作为函数对象类的构造函数参数传递，并存储它以便在调用函数时使用。也就是说，使用看起来有些不同，但可以通过某种工厂函数来简化。这是一个调整各种内容并实现相应功能对象模板的版本：

#include <cassert>

// -----------------------------------------------------------------------------

template <typename T, T> class FunctorClass;

template <typename RC, typename Class,
          RC (Class::*Member)()>
class FunctorClass<RC (Class::*)(), Member>
{
public:
    FunctorClass(Class& object): object_(&object) {}
    RC operator()() const { return (this->object_->*Member)(); }
private:
    Class* object_;
};

template <typename RC, typename Class, typename A0,
          RC (Class::*Member)(A0)>
class FunctorClass<RC (Class::*)(A0), Member>
{
public:
    FunctorClass(Class& object): object_(&object) {}
    RC operator()(A0 a0) const { return (this->object_->*Member)(a0); }
private:
    Class* object_;
};

template <typename RC, typename Class, typename A0, typename A1,
          RC (Class::*Member)(A0, A1)>
class FunctorClass<RC (Class::*)(A0, A1), Member>
{
public:
    FunctorClass(Class& object): object_(&object) {}
    RC operator()(A0 a0, A1 a1) const { return (this->object_->*Member)(a0, a1); }
private:
    Class* object_;
};

// -----------------------------------------------------------------------------

class MyClass
{
 public:
    int foo() { return 17; }
    float Fraction( float n, int m)
    {
        return n/m;
    }
    int Increment(int n)
    {
        return n+1;
    }
};

int main()
{
    MyClass object;
    int i = FunctorClass<int (MyClass::*)(), &MyClass::foo>(object)();
    assert(i == 17);

    int k = FunctorClass<int (MyClass::*)(int), &MyClass::Increment>(object)(3);
    assert(k == 4);
    float l = FunctorClass<float (MyClass::*)(float, int), &MyClass::Fraction>(object)(4,3);
    assert(l == (4.0f/3));
}

Answer 2

我不确定你是否需要变量来完成这个任务。考虑以下接口...

template < typename RETURN_TYPE >
class iFunctor abstract {

    public:

        virtual RETURN_TYPE operator () ( void ) = 0;

};

抽象接口不是成熟的类，它们可以包含部分实现，例如函数签名和一些数据成员。使用模板，您可以概括返回类型。但是你说的参数列表呢？

请注意接口中没有构造函数。在具体类（或派生类）中，您可以将变量参数列表的负担传递给构造函数，就像这样......

template < typename TYPE >
class ConcreteFunctor_add : public iFunctor < TYPE > {

    private:

       int A;
       int B;

    public:

       explicit ConcreteFunctor_add ( const int &a, const int &b ) : A(a), B(b) {};

       TYPE operator () ( void ) { return ( A + B ); };

};

您可以通过构造函数根据具体情况处理参数列表。

显式构造函数在声明时需要参数列表，因此您将在此处获取变量列表。所以在实践中......

ConcreteFunctor_add < int > addInteger ( 10, 10 );
addInteger();

你会很酷。