c++ - 具有嵌套表达式模板的C++类

我想定义一个称为Nested的类，该类将包含两个或多个(这里一个)数据成员，这些成员支持使用表达式模板(例如std::valarray)进行算术运算。对于此类本身，我正在定义其自己的表达式模板，并且希望将算术运算“转发”给成员。

下面给出一个最小的(非)工作示例:

#include <iostream>
#include <valarray>

template <typename E>
struct NestedExpr {
    operator const E& () const {
        return *static_cast<const E*>(this);
    }
};

template <typename A>
class Nested : public NestedExpr <Nested<A>>{
private:
    A a;
public:
    Nested(const A& _a) : a(_a) {}

    template <typename E>
    inline Nested<A>& operator = (const NestedExpr<E>& _expr) {
        const E& expr(_expr);
        a = expr.get_a();
        return *this;
    }

    inline       A& get_a()       { return a; }
    inline const A& get_a() const { return a; }
};

// ================================================================= //
template <typename ARG, typename S>
class NestedMul : public NestedExpr<NestedMul<ARG, S>> {
public:
    const ARG& arg;
    const S      s;
    NestedMul(const ARG& _arg, S _s) : arg(_arg), s(_s) {}
    inline auto get_a() const { return arg.get_a() * s; };
};

template< typename ARG, typename S>
inline NestedMul<ARG, S> operator * (S s, const NestedExpr<ARG>& arg) {
    return {arg, s};
}

// ================================================================= //
template <typename ARG1, typename ARG2>
class NestedAdd : public NestedExpr<NestedAdd<ARG1, ARG2>> {
public:
    const ARG1& arg1;
    const ARG2& arg2;
    NestedAdd(const ARG1& _arg1, const ARG2& _arg2)
        : arg1(_arg1), arg2(_arg2) {}
    inline auto get_a() const { return arg1.get_a() + arg2.get_a(); };
};

template<typename ARG1, typename ARG2>
inline NestedAdd<ARG1, ARG2>
operator + (const NestedExpr<ARG1>& arg1, const NestedExpr<ARG2>& arg2) {
    return {arg1, arg2};
}

int main () {
    std::valarray<double> x1 = {4.0};
    std::valarray<double> x2 = {3.0};
    std::valarray<double> x3 = {0.0};
    std::valarray<double> x4 = {0.0};

    auto a = Nested<std::valarray<double>>(x1);
    auto b = Nested<std::valarray<double>>(x2);
    auto c = Nested<std::valarray<double>>(x3);

    // this returns 21
    c  = 2*a  + 3*b;
    std::cout << c.get_a()[0] << std::endl;

    // works as expected, returns 17
    x4 = 2*x1 + 3*x2;
    std::cout <<        x4[0] << std::endl;
}

该程序的输出是

21
17

即将表达式向下传递给成员似乎无法提供直接从使用valarrays获得的预期结果。

感谢您的帮助。

最佳答案

在下面的函数定义中:

inline auto get_a() const { return arg.get_a() * s; };

您的预期行为是auto推导std::valarray<double>，即std::valarray<double>和int乘积的结果类型，这是一个新对象，已经存储了乘以整数的值。

这是operator*的定义方式[valarray.binary]/p2:

template <class T>
valarray<T> operator*(const valarray<T>&,
                      const typename valarray<T>::value_type&);

但是，标准[valarray.syn]/p3中包含以下段落:

此类型必须可以转换为std::valarray<double>，但是出于优化目的，它本身可能无法表示转换之前的实际结果。

也就是说，这是GCC为auto推导的实际类型:

std::_Expr<std::__detail::_BinClos<std::__multiplies
                                 , std::_ValArray
                                 , std::_Constant, double, double>, double>

这是Clang的用途:

std::__1::__val_expr<std::__1::_BinaryOp<std::__1::multiplies<double>,
                     std::__1::valarray<double>, std::__1::__scalar_expr<double> > >

换句话说，您将按值返回一个可能会延迟实际计算的对象。为此，这些中间对象需要以某种方式存储延迟的子表达式。

查看GCC libstdc++的实现，可以找到以下表示形式:

template <class _Oper, class _FirstArg, class _SecondArg>
class _BinBase
{
public:
    typedef typename _FirstArg::value_type _Vt;
    typedef typename __fun<_Oper, _Vt>::result_type value_type;

    _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
    : _M_expr1(__e1), _M_expr2(__e2) {}

    // [...]

private:
    const _FirstArg& _M_expr1;
    const _SecondArg& _M_expr2;
};

请注意，子表达式存储为引用。这意味着在get_a()的定义中:

return arg1.get_a() + arg2.get_a();

_M_expr1和_M_expr2绑定(bind)到临时对象:

arg1.get_a()

arg2.get_a()

即作为乘法结果的中间对象，其生存期将在NextedAdd::get_a()退出后立即终止，当最终计算结果时，特别是在实现尝试访问该中间子表达式的每个单独元素时，导致未定义的行为:

value_type operator[](size_t __i) const
{
    return _Oper()(_M_expr1[__i], _M_expr2[__i]);
}

一种快速的解决方案是使用以下返回类型:

std::decay_t<decltype(arg.get_a())> get_a() const { return arg.get_a() * s; }

这将递归地确保任何操作的最终结果类型都将是T中的原始Nested<T>类型为std::valarray<double>。

DEMO

关于c++ - 具有嵌套表达式模板的C++类，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/53564098/