表达式模板(expression templates)

表达式模板(expression templates)

Blitz++是一个高性能数组算术程序库，开拓性的使用了explicit metaprograming。

如果将其所解决的问题归结为一句话，那就是：数组算术的幼稚实现，对于任何有意义的计算来说，是可怕低效的。为了弄明白这句话所表达的意思，看看下面几条无趣的语句：

x = a + b + c;

其中x, a, b ,c 都是二维数组。数组加法运算符的规范实现是：

template

Matrix<_Ty> operator + (Matrix<_Ty> const & a, Matrix<_Ty> const & b)

{

Matrix<_Ty> result(n, m);

…

return result;

}

这里就有两个对象被创建了，一个是result，一个是函数返回值的临时对象，Effective C++条告诉我们:

条款23: 必须返回一个对象时不要试图返回一个引用，这里就是典型的例子。当然现代编译器所做的比我们想象的要多很多，
对于result这类具名的返回值，在编译器优化阶段能够被侦测，然后与返回值临时对象合并(NVRO)，然而在
x = a + b + c;
这一表达式中，产生的临时对象依然会有两个，就是a+b的结果t1，t1+c的结果t2; t2 + c 的结果t2，在高性能计算
领域，临时对象一直是C/C++ 被诟病的主要原因之一。在函数式程序设计语言中往往有着 惰性求值这一特性，即只有当表达式确实需要时才对其求值。=

在表达式解析树(parse tree)中，评估始于叶子节点并向上推进直至根节点。如何才能至上向下的管理表达式计算成为了问题的关键。

下图为x = a + b + c 的解析树。

当然这不是一个一般的表达式，矩阵（二维数组）表达式涉及了其他的一些操作，比如乘法，这些操作需要他们自己的评估策略，并且表达式可能是任意大并且是嵌套的，如果采用指针和节点构建的解析树，不得不在运行期遍历解析树，这势必对性能造成影响。由此表达式模版应运而生。

其实作手法还是相当直接的，临时变量来源于不必要的求值，那就不求值就行了，让operator+不返回计算出来的结果，而仅仅是将实参的引用打包到一个Expression实体中，并贴以标签：

// 操作标签

struct plus; struct minus;

// 表达式树节点

template

struct Expression

// 加法运算符

template

Expression operator+(L const& l, R const& r)

{ return Expression (l, r); }

当我们写下a+b时，并没有足够的信息执行计算，它被编码为Expression ，数据通过表达式所存储的引用进行访问。当写下a+b+c时，得到一个如下类型的结果

Expression , plus, Matrix>

但这一切究竟是怎样工作的，让我们看看一个矩阵的加法如何操作的

//加法标签实现逐元素的计算

// 操作标签

struct plus

{

template

static _Ty apply(_Ty a, _Ty b) { return a + b; }

};

然后给表达式Expression一个索引操作

template

struct Expression

{

Expression(_Tl const& lhs, _Tr const& rhs)

: _Lexpr(lhs), _Rexpr(rhs)

{}

value_type operator() (size_type idx, size_type idy) const

{ return OpTag::apply(_Lexpr(idx,idy), _Rexpr(idx, idy));}

_Tl const& _Lexpr;

_Tr const& _Rexpr;

};

这看起来非常简单，然而令人惊讶的是，现在获得了完整的缓式表达式评估(lazy expression evaluation)功能。

注意到Expression的构造函数除了保存引用之外，其实什么也没做。只有执行索引操作时才会评估值，比如表达式a + b，类型是Expression

(a+b)(0,0) == plus::apply(a(0,0) + b(0,0))

== a(0,0) + b(0,0)

同样(a+b+c)[0,0]也在不产生任何临时矩阵的情况下被计算出来：

(a+b+c)(0,0) == plus::apply((a+b)(0,0) , c(0,0))

== plus::apply(plus::apply(a(0,0), b(0,0)), c(0,0))

== plus::apply(a(0,0) + b(0,0), c(0,0))

== a(0,0) + b(0,0) + c(0,0)

现在剩下的就是去实现Matrix赋值运算符了，我们可以访问结果Expression的任何单个元素，二不必去创建临时的Matrix，因此可以通过访问表达式中的每一个元素来计算整个结果：

template

Matrix& operator=(Expr const & expr)

{

size_type n = Row(), m = Col();

for (size_type i = 0; i != n; ++i)

for (size_type j = 0; j != m; ++j)

(*this)(i, j) = expr(i, j);

return *this;

}

没有任何东西是完美无缺的，表达式模版的缺点之一是它们鼓励编写复杂的大型表达式，因为评估被延迟到了赋值运算符调用时，如果程序员希望复用某写中间结果，而早期又没有评估它，她就被迫声明一个类似如下(甚至更糟)的复杂类型：

Expression<

Expression

, plus

, Expression

> temp = a + b + (c – d);

这个类型不但精确而且累赘的反映了计算结构，而且很打击人的信心。通常的迂回解决方式是使用类型擦出来捕获表达式，当然这种情况下会付出相应的代价(动态分派)。

当然这已经不是问题了，C++0x把关键字auto变废为宝，以便在形形色色的声明中进行类型推导，从而我们只需写下:

auto temp = a + b + (c – d);

更多auto的来源及特性见N1705=04-0145 Decltype and auto。