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

Question

我想定义一个类，在这里称为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 获得的预期结果。

感谢这里的任何帮助。

Answer 1

在下面的函数定义中：

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 中有以下段落：

任何返回valarray<T>的函数都可以返回其他类型的对象，前提是valarray<T>的所有 const 成员函数也适用于此类型。此返回类型不得在嵌套最深的参数类型上添加两级以上的模板嵌套。

此类型必须可转换为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绑定到临时对象：

• 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; }

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

演示