模板仿函数必须提供自己作为模板参数

Question

我非常希望能够提供仿函数作为模板参数。函数必须能够提供“自己”作为该论证。

我想是这样的：

template<typename T, template<typename> class SumFunctor> class foo; 

template<typename T> 
struct sum_default 
{ 
    foo<T, sum_default> operator()(foo<T, sum_default> a, foo<T, sum_default> b) const 
    { 
      T a_data = a.data(); 
      T b_data = b.data(); 
      return foo<T, sum_default>(a_data + b_data); 
    } 
}; 

template<typename T> 
struct sum_awesome 
{ 
    foo<T, sum_awesome> operator()(foo<T, sum_awesome> a, foo<T, sum_awesome> b) const 
    { 
      T a_data = a.data(); 
      T b_data = b.data(); 
      return foo<T, sum_awesome>(a_data - b_data); 
    } 
}; 

template<typename T=int, template<typename> class SumFunctor=sum_default> 
class foo 
{ 
private: 
    T _data; 
    SumFunctor<T> _functor; 
public: 
    foo<T, SumFunctor>(T data) : _data(data) {} 

    T data() { return _data; } 

    friend const foo operator +(const foo& lhs, const foo& rhs) 
    { 
      return lhs._functor(lhs,rhs); 
    } 
}; 

int main(){ 
    foo<> a(42); 
    foo<double> b(1.0); 
    foo<double,sum_default> c(4.0); 
    foo<double,sum_awesome> d(4.0); 

    a+a; 
    d+d; 
} 

这是可能的，如果是这样，怎么样？

另一种解决方案是为构造函数提供函子，但是我认为这非常难看，因为用户必须自己动态地分配函数（因为我们无法确定构造函数中的函数的类型。这样做似乎也有点难看）：

foo<double> a(42, new sum_default<double>()); 

这也迫使从一些预先定义的基本算符派生的所有仿函数。

UPDATE

试图模板参数添加到sum_default模板参数没有出现要解决的问题：

template<typename T> 
struct sum_default 
{ 
// Error 1 error C3200: 'sum_default<T>' : invalid template argument for template parameter 'SumFunctor', expected a class template 
foo<T, sum_default<T> > operator()(foo<T, sum_default<T> > a, foo<T, sum_default<T> > b) const 
{ 
    T a_data = a.data(); 
    T b_data = b.data(); 
    return foo<T, sum_default<T> >(a_data + b_data); 
} 
}; 

Answer 1

什么咬你在这里被称为“类名称注射” –内的类模板，例如Foo<T>，不合格使用Foo实际上视为Foo<T>。引用C++ 11§14.6.1/ 1：

与正常（非模板）类相似，类模板具有注入类名。注入的类名称可以用作模板名称或类型名称。当它被用来与模板参数列表，作为模板参数为模板模板参数，或如在最终标识符阐述型说明符朋友类模板声明的它指的是类模板本身。否则，它相当于模板名称后面跟着模板参数，该模板参数包含在<>中的类模板中。

因此，中sum_default<T>里面，当你有foo<T, sum_default>，它会被视为虽然您键入foo<T, sum_default<T> >（其为foo想要一个模板的模板参数显然不会工作）。

为了避免这种情况，您需要限定这些类模板中类模板名称的用法。因为你的类模板是在全球范围内，::足够：

template<typename T> 
struct sum_default; 

template<typename T = int, template<typename> class SumFunctor = sum_default> 
class foo 
{ 
    T _data; 
    SumFunctor<T> _functor; 

public: 
    foo<T, SumFunctor>(T data) : _data(data) { } 

    T data() { return _data; } const 

    friend foo operator +(foo const& lhs, foo const& rhs) 
    { 
     return lhs._functor(lhs, rhs); 
    } 
}; 

template<typename T> 
struct sum_default 
{ 
    foo<T, ::sum_default> operator()(foo<T, ::sum_default> a, 
             foo<T, ::sum_default> b) const 
    { 
     return foo<T, ::sum_default>(a.data() + b.data()); 
    } 
}; 

template<typename T> 
struct sum_awesome 
{ 
    foo<T, ::sum_awesome> operator()(foo<T, ::sum_awesome> a, 
            foo<T, ::sum_awesome> b) const 
    { 
     return foo<T, ::sum_awesome>(a.data() - b.data()); 
    } 
}; 

int main() 
{ 
    foo<> a(42); 
    foo<double> b(1.0); 
    foo<double, sum_default> c(4.0); 
    foo<double, sum_awesome> d(4.0); 

    a + a; 
    d + d; 
} 

注意，这也可以让你正是如此定义foo的构造，降低噪音位：

foo(T data) : _data(data) { }