2

我想定义一个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

即，将表达式向下转发给成员似乎无法提供直接从使​​用 valarray 获得的预期结果。

任何帮助在这里表示赞赏。

4

1 回答 1

1

在下面的函数定义中：

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

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

这就是[valarray.binary]/p2operator*的定义方式：

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

但是，标准[valarray.syn]/p3中有以下段落：

任何返回 a 的函数valarray<T>都可以返回另一种类型的对象，只要它的所有 const 成员函数valarray<T>也适用于这种类型。此返回类型不应在嵌套最深的参数类型上添加超过两层的模板嵌套。

此类型必须可转换为std::valarray<double>，但出于优化目的，它本身可能不代表转换发生之前的实际结果。

也就是说，这是autoGCC 推导出的实际类型：

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绑定到临时对象：

  • 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>.

演示

于 2018-12-01T09:44:46.703 回答