表达式模板解决的问题是：
对于一个数值数组类，它需要为基于整个数组对象的数值操作提供支持，如对数组求和或放大：
Array<double> x(), y();
...
x = 1.2 * x + x * y;
对效率要求苛刻的数值计算器，会要求上面的表达式以最高效的方式进行求值。想既高效又以这种比较紧凑的运算符写法来实现，表达式模板可以帮助我们实现这种需求。
谈到表达式模板，自然联想到前面的template metaprogramming。一方面：表达式模板有时依赖于深层的嵌套模板实例化，而这种实例化又和我们在template metaprogramming中遇到的递归实例化非常相似；另一方面：最初开发这两种实例化技术都是为了支持高性能的数组操作，而这又从另一个侧面说明了metaprogramming和表达式模板是息息相关的。当然，这两种技术还是互补的。例如，metaprogramming主要用于小的，大小固定的数组，而表达式模板则适用于能够在运行期确定大小、中等大小的数组。
18.1 临时变量和分割循环
书中本节讲解了使用普通的运算符重载方法，临时变量的构造和多次的读写操作带来的低效，以及使用包含计算的赋值运算符（如+=，*=等），即便可以避免过多的临时变量构造，却依旧进行了多次读写以致并没有带来明显的效率提高，同时引入并不雅观的代码。
有兴趣详见书籍；
18.2 在模板实参中编码表达式
前面的问题中，我们注意到：直到看到了整个表达式的时候（在我们的例子中，即在调用赋值运算符的时候），才对表达式的各个部分进行求值。下面我们要做的，就是把表达式：
1.2*x + x*y;
转化为一个具有如下类型的对象：
A_Add< A_Mult<A_Scalar<double>, Array<double> >,
A_Mult<Array<double>, Array<double> > >
18.2.1 表达式模板的操作数
首先我们来实现A_Add和A_Mult，A_Scalar类：
---------------------- 标识1 ------------------------
// exprtmpl/exprops1.hpp #include <stddef.h>
#include <cassert>
// 包含了一个辅助class trait template, 从而可以根据不同的情况，判断究竟是以“传值”的方式还是以“传引用”的方式来引用对应的“表达式模板节点”：
#include "exprops1a.hpp" // 表示两个操作数之和的对象的所属类
template <typename T, typename OP1, typename OP2>
class A_Add
{
private:
// 这里使用辅助类A_Traits的原因参见 “标识4”
typename A_Traits<OP1>::ExprRef op1; // 第1个操作数
typename A_Traits<OP2>::ExprRef op2; // 第2个操作数 public:
// 构造函数，用于初始化指向操作数的引用
A_Add(OP1 const& a, OP2 const& b) : op1(a), op2(b) { } // 在求值的时候计算和
// 但最外层的变量调用[]运算符的时候，会一层一层调用到最原始类型的[]运算符
T operator[] (size_t idx) const
{
return op1[idx] + op2[idx];
} // size代表最大的容量（大小）
size_t size() const
{
assert (op1.size() == || op2.size() == || op1.size() == op2.size() );
return op1.size() != ? op1.size() : op2.size();
}
}; // 表示两个操作数之积的对象的所属类
template <typename T, typename OP1, typename OP2>
class A_Mult
{
private:
typename A_Traits<OP1>::ExprRef op1; // 第1个操作数
typename A_Traits<OP2>::ExprRef op2; // 第2个操作数 public:
// 构造函数，用于初始化对象指向操作数的引用
A_Mult(OP1 const& a, OP2 const& b) : op1(a), op2(b) { } // 在求值的时候计算乘积
// 但最外层的变量调用[]运算符的时候，会一层一层调用到最原始类型的[]运算符
T operator[] (size_t idx) const
{
return op1[idx] * op2[idx];
} // size代表最大的容量（大小）
size_t size() const
{
assert (op1.size() == || op2.size() == || op1.size() == op2.size() );
return op1.size() != ? op1.size() : op2.size();
}
}; exprtmpl/exprscalar.hpp
// 用于表示放到倍数的对象的所属类
template <typename T>
class A_Scalar
{
private:
T const& s; // scalar的值
public:
// 构造函数，用于初始值
A_Scalar (T const& v) : s(v) { } // 对于索引（下标）操作而言，每个元素的值都等于scalar（放大倍数）的值
T operator[] (size_t) const {
return s
} // scalar 的大小（即元素个数）为0
size_t size() const{
return ;
}
};
18.2.2 Array 类型
---------------------- 标识2 ------------------------
既然能够使用轻量级的表达式模板来对表达式进行编码，下面我们创建一个Array:它既能够针对占用实际内存的数组，同时也适用于表达式模板。
// Rep类型要么是SArray,但前提是Array必须是一个占用实际存储空间的数组；要么是一个用于编码表达式的嵌套template-id,如A_Add和A_Mult。
// exprtmpl/exprarray.hpp
#include <stddef.h>
#include <cassert>
#include "sarray1.hpp" template <typename T, typename Rep = SArray<T> >
class Array
{
private:
Rep expr_rep; // (访问)数组的数据 public:
// 创建具有初始化大小的数组
explicit Array (size_t s) : expr_rep(s) { } // 根据其他可能的表示来创建数组
Array (Rep const& rb) ; expr_rep(rb) { } // 针对相同类型的赋值运算符
Array& operator = (Array const& b) {
assert (size() == b.size() );
for (size_t idx = ; idx < b.size(); ++idx)
{
expr_rep[idx] = b[idx];
}
return *this;
} // 针对不同类型的赋值运算符
template <typename T2, typename Rep2>
Array& operator = (Array<T2, Rep2> const& b) {
assert (size() == b.size() );
for (size_t idx = ; idx < b.size(); ++idx)
{
expr_rep[idx] = b[idx];
}
return *this;
} // size 是所表示数据的大小
size_t size() const{
return expr_rep.size();
} // 分别针对常量和变量的索引（下标）运算符
T operator[] (size_t idx) const {
assert(idx < size() );
return expr_rep[idx];
} T& operator[] (size_t idx) const {
assert(idx < size() );
return expr_rep[idx];
} // 返回数组现在所表示的对象
Rep const& rep() const {
return expr_rep;
} Rep& rep(){
return expr_rep;
}
};
18.2.3 运算符
---------------------- 标识3 ------------------------
到目前为止，我们只是实现了用于代表运算符的、针对数值Array模板的运算符操作（诸如A_Add），但仍然没有实现运算符本身（诸如+）。下面我们来做这件事：
// exprtmpl/exprops2.hpp
// 两个数组相加
template <typename T, typename R1, typename R2>
Array<T, A_Add<T, R1, R2> >
operator + (Array<T, R1> const& a, Array<T, R2> const& b){
return Array<T, A_Add<T, R1, R2> >(A_Add<T, R1, R2>(a.rep(), b.rep() ));
} // 两个数组相乘
template <typename T, typename R1, typename R2>
Array<T, A_Mult<T, R1, R2> >
operator * (Array<T, R1> const& a, Array<T, R2> const& b){
return Array<T, A_Mult<T, R1, R2> >(A_Mult<T, R1, R2>(a.rep(), b.rep() ));
} // scalar 和 数组相乘
template <typename T, typename R2>
Array<T, A_Mult<T, A_Scalar<T>, R2> >
operator * (T const& s, Array<T, R2> const& b){
return Array<T, A_Mult<T, A_Scalar<T>, R2> >(A_Mult<T, A_Scalar<T>, R2>(A_Scalar<T>(s), b.rep() ));
} // 数组和scalar相乘
// scalar和数组相加
// 数组和scalar相加
...
18.2.4 总结
针对前面的例子代码，我们来进行一个自顶向下的回顾：
int main()
{
Array<double> x(), y();
...
x = 1.2*x + x*y;
}
（1）首先，编译器解析最左边的*运算符,它是一个scalar-array运算符：
template <typename T, typename R2>
Array<T, A_Mult<T, A_Scalar<T>, R2> > // 返回类型
operator * (T const& s, Array<T, R2> const& b){
return Array<T, A_Mult<T, A_Scalar<T>, R2> > // 类型转换
(A_Mult<T, A_Scalar<T>, R2> // 模板参数
(A_Scalar<T>(s), b.rep() )); // 构造函数参数
}
其中操作数的类型是double和Array<double, SArray<double> >。因此，实际的结果类型是：
Array<double, A_Mult<double, A_Scalar<double>, SArray<double> > >
而结果值是一个构造自double值1.2的A_Scalar<double>对象，和一个表示对象x的SArray<double>对象。
（2）接下来，将会对第2个乘法进行求值：x*y是一个array-array操作：
template <typename T, typename R1, typename R2>
Array<T, A_Mult<T, R1, R2> >
operator * (Array<T, R1> const& a, Array<T, R2> const& b){
return Array<T, A_Mult<T, R1, R2> >
(A_Mult<T, R1, R2>(a.rep(), b.rep() ));
}
而两个操作数的类型都是Array<double, SArray<double> >, 因此结果类型为：
Array<double, A_Mult<double, SArray<double>, SArray<double> > >
这一次，A_Mult所封装的两个参数对象都引用了一个SArray<double>表示：即一个用于表示x对象，另一个用于表示y对象。
（3）最后，才对+运算符进行求值。这次还是array-array操作：
template <typename T, typename R1, typename R2>
Array<T, A_Add<T, R1, R2> >
operator * (Array<T, R1> const& a, Array<T, R2> const& b){
return Array<T, A_Add<T, R1, R2> >
(A_Add<T, R1, R2>(a.rep(), b.rep() ));
}
其中用double来替换T,R1则用：
A_Mult<double, A_Scalar<double>, SArray<double> >
进行替换，而R2则替换为：
A_Mult<double, SArray<double>, SArray<double> >
因此，赋值运算符右边的表达式最终的类型为：
Array<double,
A_Add<double,
A_Mult<double, A_Scalar<double>, SArray<double> >,
A_Mult<double, SArray<double>, SArray<double> > > >
这个类型将与Array模板的赋值运算符模板进行匹配：
template <typename T, typename Rep = SArray<T> >
class Array
{
public:
... // 针对相同类型的赋值运算符
Array& operator = (Array const& b) {
assert (size() == b.size() );
for (size_t idx = ; idx < b.size(); ++idx)
{
expr_rep[idx] = b[idx];
}
return *this;
} ...
};
其中赋值运算符将会运用右边Array（即b）的下标运算符来计算目标数组x的每一个元素，其中右边Array的实际类型为：
A_Add<double,
A_Mult<double, A_Scalar<double>, SArray<double> >,
A_Mult<double, SArray<double>, SArray<double> > >
如果我们仔细跟踪这个下标操作，那么对于一个给定的下标x，将会得到：
b[idx]实际展开成：(1.2*x[idx]) + (x[idx]*y[idx])
也即： x = 1.2*x + x*y;
表达式首先根据"标识3"规则进行展开，然后，再进一步根据"标识1"进行展开，在"标识1"中，针对每一个原始类型执行实际的数值操作（包括下标运算符操作）。
---------------------- 标识4 ------------------------
标识1中的运算符类使用了一个辅助类A_Traits，来定义操作数成员，是必要的：
typename A_Traits<OP1>::ExprRef op1; // 第1个操作数
typename A_Traits<OP2>::ExprRef op2; // 第2个操作数
原因在于：通常而言，我们可以把这些操作数声明为引用类型，因为大多数局部节点是在顶层表达式进行绑定的，因此它们的生命周期能够延续到完整表达式的求值。但是，唯一的例外是A_Scalar节点，它是在运算符函数内部进行绑定的，所以并不能一直存在到完整表达式的求值。因此，为了使放到倍数的成员能够一直存在到完整表达式求值，我们需求对scalar操作数进行“传值拷贝”，而不是“传引用拷贝”。也即：
（1）通常情况下是常数引用：
OP1 const& op1; // 指向第1个操作数的引用
OP2 const& op2; // 指向第2个操作数的引用
（2）对于scalar值，则是普通值：
OP1 op1; // 以传值拷贝的方式引用第1个操作数
OP2 op2; // 以传值拷贝的方式引用第2个操作数
故而，trait class 定义如下：它定义了一个针对大多数常数引用的基本模板，但同时定义了一个针对scalar的特化：
// exprtmpl/expropsla.hpp /* 用于选择如何引用“表达式模板节点”的辅助trait class
* - 通常情况下：传引用
* - 对于scalar：传值
*/ template <typename T> class A_Scalar; // 基本模板
template <typename T>
class A_Traits
{
public:
typedef T cosnt& ExprRef; // 所引用的类型typedef成一个常量引用
}; // 针对scalar的局部特化
template <typename T>
class A_Traits<A_Scalar<T> >
{
public:
typedef A_Scalar<T> ExprRef; // 所引用的类型实际是一个普通值
};