c++ - 如何针对特定类型使用表达式模板？

Question

使用表达式模板时，如何创建特化？来自Wikipedia example ，我可以像这样制作一个 vector 和模板类:

template <typename E1, typename E2>
class VecSum : public VecExpression<VecSum<E1, E2> > {
    E1 const& _u;
    E2 const& _v;
public:
    VecSum(E1 const& u, E2 const& v) : _u(u), _v(v) {
        assert(u.size() == v.size());
    }
    double operator[](size_t i) const { return _u[i] + _v[i]; }
    size_t size()               const { return _v.size(); }
};

template <typename E1, typename E2>
VecSum<E1,E2> const
operator+(E1 const& u, E2 const& v) {
   return VecSum<E1, E2>(u, v);
}

根据维基百科，如果我有 Vector扩展类 VecExpression<Vector>和 VecExpression 的构造函数使用 [] 的类运算符和循环，这将允许循环合并，因此如下所示的语句仅使用单个循环:

Vector a = ...;
Vector b = ...;
Vector c = ...;
Vector d = a+b+c;

我明白为什么这有效，但我不确定如何将其扩展到标量。我希望能够向整个 Vector 添加标量(int、float 或 double)，但我不确定如何执行此操作。我最好的猜测是为 VecSum 类创建特化，例如:

template<typename E2> VecSum<int, E2>{ /*stuff goes here*/ }
template<typename E1> VecSum<E1, int>{ /*stuff goes here*/ }
template<typename E2> VecSum<float, E2>{ /*stuff goes here*/ }
template<typename E1> VecSum<E1, float>{ /*stuff goes here*/ }
template<typename E2> VecSum<double, E2>{ /*stuff goes here*/ }
template<typename E1> VecSum<E1, double>{ /*stuff goes here*/ }

但这似乎比必要的工作多了很多，还有其他解决方案吗？

Answer 1

只需使用 SFINAE 检查类型是否为算术类型并根据需要进行专门化。示例:

template <typename E1, typename E2, typename Enable = void > class VecSum;

template <typename E1, typename E2>
class VecSum< E1, E2,
      typename std::enable_if_t<!std::is_arithmetic<E1>::value && !std::is_arithmetic<E2>::value>
      > : public VecExpression<VecSum<E1, E2> >
{
    E1 const& _u;
    E2 const& _v;

    public:

    VecSum(E1 const& u, E2 const& v) : _u(u), _v(v)
    {
        assert(u.size() == v.size());
    }

    double operator[](size_t i) const { return _u[i] + _v[i]; }
    size_t size()               const { return _v.size(); }
};

template <typename E1, typename E2>
class VecSum < E1, E2,
      typename std::enable_if_t< std::is_arithmetic<E1>::value && !std::is_arithmetic<E2>::value>
      > : public VecExpression<VecSum<E1, E2> >
{
    E1 const& _u;
    E2 const& _v;

    public:

    VecSum(E1 const& u, E2 const& v) : _u(u), _v(v)
    {
    }

    double operator[](size_t i) const { return _u + _v[i]; }
    size_t size()               const { return _v.size(); }
};


template <typename E1, typename E2>
class VecSum < E1, E2,
      typename std::enable_if_t< !std::is_arithmetic<E1>::value && std::is_arithmetic<E2>::value>
      > : public VecExpression<VecSum<E1, E2> >
{
    E1 const& _u;
    E2 const& _v;

    public:

    VecSum(E1 const& u, E2 const& v) : _u(u), _v(v)
    {
    }

    double operator[](size_t i) const { return _u[i] + _v; }
    size_t size()               const { return _u.size(); }
};

int main(){
    Vec v0 = { 1, 2, 3 ,4 };
    Vec v1 = {10, 20,30,40 };
    Vec v2 = {100,200,300,400 };

    {

        Vec sum = v0+v1+v2;
        Vec v3(4);

        for(int i=0;i<4;++i)
            v3[i]=sum[i];


        for(unsigned int i=0;i<v3.size();++i)
            std::cout << v3[i] << std::endl;
    }

    std::cout << "with lhs skalar" << std::endl;

    {
        Vec sum = 5 + 50 + v1;
        Vec v3(4);

        for(int i=0;i<4;++i)
            v3[i]=sum[i];


        for(unsigned int i=0;i<v3.size();++i)
            std::cout << v3[i] << std::endl;

    }

    std::cout << "with rhs skalar" << std::endl;

    {
        Vec sum = v1 + 5 + 50 ;
        Vec v3(4);

        for(int i=0;i<4;++i)
            v3[i]=sum[i];


        for(unsigned int i=0;i<v3.size();++i)
            std::cout << v3[i] << std::endl;

    }

}