expression template

表达式模板是一种C++模板元编程(template metaprogram)技术。典型情况下，表达式模板自身代表一种操作，模板参数代表该操作的操作数。模板表达式可将子表达式的计算推迟，这样 有利于优化(特别是减少临时变量的使用)。表达式模板也可以作为参数传递给一个函数。

例子：我们实现一个用来求表达式 x = 1.2*x + x*y 的模板表达式，其中x、y为数组

//exprarray.h
#include <stddef.h>
#include <cassert>
#include "sarray.h"

template<typename T>
class A_Scale
{
public:
	A_Scale(T const& t):value(t){}
	T operator[](size_t) const
	{
		return value;
	}
	size_t size() const
	{
		return 0;
	}
private:
	T const& value;
};

template<typename T>
class A_Traits
{
public:
	typedef T const& exprRef;
};
template<typename T>
class A_Traits<A_Scale<T> >
{
public:
	typedef A_Scale<T> exprRef;
};

template<typename T,typename L1,typename R2>
class A_Add
{
private:
	typename A_Traits<L1>::exprRef op1;
	typename A_Traits<R2>::exprRef op2;
public:
	A_Add(L1 const& a,R2 const& b):op1(a),op2(b)
	{
	}
	T operator[](size_t indx) const
	{
		return op1[indx] + op2[indx];
	}
	size_t size() const
	{
		assert(op1.size()==0 || op2.size()==0 || op1.size() == op2.size());
		return op1.size() != 0 ? op1.size() : op2.size();
	}
};

template<typename T,typename L1,typename R2>
class A_Mul
{
private:
	typename A_Traits<L1>::exprRef op1;
	typename A_Traits<R2>::exprRef op2;
public:
	A_Mul(L1 const& a,R2 const& b):op1(a),op2(b)
	{
	}
	T operator[](size_t indx) const
	{
		return op1[indx] * op2[indx];
	}
	size_t size() const
	{
		assert(op1.size()==0 || op2.size()==0 || op1.size() == op2.size());
		return op1.size() != 0 ? op1.size():op2.size();
	}
};

template<typename T,typename Rep = SArray<T> >
class Array
{
public:
	explicit Array(size_t N):expr_Rep(N){}
	Array(Rep const& rep):expr_Rep(rep){}
	Array& operator=(Array<T> const& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx < orig.size();indx++)
		{
			expr_Rep[indx] = orig[indx];
		}
		return *this;
	}
	template<typename T2,typename Rep2>
	Array& operator=(Array<T2,Rep2> const& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx<orig.size();indx++)
		{
			expr_Rep[indx] = orig[indx];
		}
		return *this;
	}
	size_t size() const
	{
		return expr_Rep.size();
	}
	T operator[](size_t indx) const
	{
		assert(indx < size());
		return expr_Rep[indx];
	}
	T& operator[](size_t indx)
	{
		assert(indx < size());
		return expr_Rep[indx];
	}
	Rep const& rep() const
	{
		return expr_Rep;
	}
	Rep& rep()
	{
		return expr_Rep;
	}
private:
	Rep expr_Rep;
};

template<typename T,typename L1,typename R2>
Array<T,A_Add<T,L1,R2> >
operator+(Array<T,L1> const& a,Array<T,R2> const& b)
{
	return Array<T,A_Add<T,L1,R2> >(A_Add<T,L1,R2>(a.rep(),b.rep()));
}

template<typename T,typename L1,typename R2>
Array<T,A_Mul<T,L1,R2> >
operator*(Array<T,L1> const& a,Array<T,R2> const& b)
{
	return Array<T,A_Mul<T,L1,R2> >(A_Mul<T,L1,R2>(a.rep(),b.rep()));
}

template<typename T,typename R2>
Array<T,A_Mul<T,A_Scale<T>,R2> >
operator*(T const& a,Array<T,R2> const& b)
{
	return Array<T,A_Mul<T,A_Scale<T>,R2> >(A_Mul<T,A_Scale<T>,R2>(A_Scale<T>(a),b.rep()));
}

 测试代码(求解表达式1.2*x+x*y)：

//test.cpp
#include "exprarray.h"
#include <iostream>
using namespace std;

template <typename T>
void print (T const& c)
{
	for (int i=0; i<8; ++i) {
		std::cout << c[i] << ' ';
	}
	std::cout << "..." << std::endl;
}

int main()
{
	Array<double> x(1000), y(1000);

	for (int i=0; i<1000; ++i) {
		x[i] = i;
		y[i] = x[i]+x[i];
	}

	std::cout << "x: ";
	print(x);

	std::cout << "y: ";
	print(y);

	x = 1.2 * x;
	std::cout << "x = 1.2 * x: ";
	print(x);

	x = 1.2*x + x*y;
	std::cout << "1.2*x + x*y: ";
	print(x);

	x = y;
	std::cout << "after x = y: ";
	print(x);

	return 0;
}

 下面我们来分析一下模板表达式的解析过程：
我们以表达式 x = 1.2*x + x*y为例
当编译器解析表达式：x = 1.2*x + x*y 的时候，编译器首先会应用最左边的*运算符，它是一个Scale-Array运算符。于是重载解析规则将会选择operator*的Scale-Array形式：

template<typename T,typename R2>
Array<T,A_Mul<T,A_Scale<T>,R2> >
operator*(T const& a,Array<T,R2> const& b)
{
	return Array<T,A_Mul<T,A_Scale<T>,R2> >(A_Mul<T,A_Scale<T>,R2>(A_Scale<T>(a),b.rep()));
}

 其中操作数的类型是double和Array<double,SArray<double> >,因此实际的结果类型是：

Array<double,A_Mul<double,A_Scale<double>,SArray<double> > >

接下来，编译器会对第二个乘法进行求值：x*y是一个array-array操作，这一次，我们将会选择operator*的Array-Array重载操作：

template<typename T,typename L1,typename R2>
Array<T,A_Mul<T,L1,R2> >
operator*(Array<T,L1> const& a,Array<T,R2> const& b)
{
	return Array<T,A_Mul<T,L1,R2> >(A_Mul<T,L1,R2>(a.rep(),b.rep()));
}

 其中两个操作数类型都是Array<double,SArray<double> >,因此结果类型为：

Array<double,A_Mul<double,SArray<double>,SArray<double> > >

这一次，A_Mul所封装的连个参数对象都引用了一个SArray<double>表示：即一个表示x对象，一个表示y对象。
现在开始对+运算符进行求值。这次还是Array-Array操作，因此调用Array-Array版本的operator+:

template<typename T,typename L1,typename R2>
Array<T,A_Add<T,L1,R2> >
operator+(SArray<T,L1> const& a,SArray<T,R2> const& b)
{
	return Array<T,L1,R2>(A_Add<T,L1,R2>(a.rep(),b.rep()));
}

 其中用double来替换T，则R1为:

A_Mul<double,A_Scale<double>,SArray<double> >

 R2为：

A_Mul<double,SArray<double>,SArray<double> >

 因此赋值表达式 x = 1.2*x + x*y的右边经过编译器解析后的最终类型为:

Array<double,
	A_Add<double,
		A_Mul<double,A_Scale<double>,SArray<double> >
		A_Mul<double,SArray<double>,SArray<double> > > >

 这个类型将与Array模板的赋值运算符模板进行匹配：

//针对不同类型数组的赋值运算符
template<typename T2,typename Rep2>
	Array& operator=(Array<T2,Rep2> const& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx<orig.size();indx++)
		{
			expr_Rep[indx] = orig[indx];
		}
		return *this;
	}

 此时，赋值运算符将会运用右边Array的下标运算符来计算目标数组的每一个元素，而Array的实际类型为：

Array<double,
	A_Add<double,
		A_Mul<double,A_Scale<double>,SArray<double> >
		A_Mul<double,SArray<double>,SArray<double> > > >

 我们记为：ArrayTgt
此时，ArrayTgt[indx]将会匹配模板类A_Add中的重载操作符operator[],即：

T operator[](size_t indx) const
	{
		return op1[indx] + op2[indx];
	}

匹配之后就变成：

A_Mul<double,A_Scale<double>,SArray<double> >[indx]
+
A_Mul<double,SArray<double>,SArray<double> >[indx]; 

 而A_Mul[indx]又会匹配模板类A_Mul中的重载操作符operator[],即：

T operator[](size_t indx) const
	{
		return op1[indx] * op2[indx];
	}

 匹配之后就变成：

A_Scale<double>[indx] * SArray<double>[indx] 
+
SArray<double>[indx] * SArray<double>[indx]

 而A_Scale[indx]又会匹配模板类A_Scale中的重载操作符operator[],即：

T operator[](size_t) const
	{
		return value;
	}

 这样最终的结果就表达式就变成:

value[indx] * SArray<double>[indx] 
+
SArray<double>[indx] * SArray<double>[indx]

至此，整个模板表达式的解析工作已经完成，只需进行计算即可。在整个计算过程中，没有产生任何的中间变量，所以程序的效率得以大幅的提高。

程序注意事项：
1.在上述代码中，如果将模板类Array的代码：

Array& operator=(Array<T2,Rep2> const& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx<orig.size();indx++)
		{
			expr_Rep[indx] = orig[indx];
		}
		return *this;
	}

 中的参数改为Array<T2,Rep2> & orig，即变成：

Array& operator=(Array<T2,Rep2>& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx<orig.size();indx++)
		{
			expr_Rep[indx] = orig[indx];
		}
		return *this;
	}

将会导致编译出错，原因是：
在test.cpp文件中，我们使用了表达式：x = 1.2 * x ，这个表达式的右边将会被编译器解析为如下形式的表达式：

Array<double,A_Mul<double,A_Scale<double>,SArray<doube> > >

 这样在进行重载操作符operator[]的匹配时，将会变成如下形式：

SArray[indx] = A_Scale[indx] * SArray[indx]

 到了这一步，问题就出现了，因为A_Scale[indx]会匹配模板类Array中的重载操作符operator[],但是我们发现在模板类Array代码中，有两个重载的operator[],即：

T operator[](size_t indx) const
	{
		assert(indx < size());
		return expr_Rep[indx];
	}
T& operator[](size_t indx)
	{
		assert(indx < size());
		return expr_Rep[indx];
	}

如果我们没在重载操作符operator=的参数中写入const的话，这里会优先调用无const的operator[]重载函数，但是A_Scale[indx]是个常数，在本例中也就是一个double类型，这样最后在调用operator[]返回的时候就出现了类型不匹配的现象，因为无const的operator[]返回的类型是double&,所以会报错。当然，我们可以将test.cpp程序中的表达式1.2*x去掉，我们会发现，这个时候无const的operator=就会编译通过。

2.在上述代码中，模板类Array的构造函数代码为：
explicit Array(size_t N):expr_Rep(N){}
这表明定义Array必须通过显式转型，不能通过隐式转型。下述代码会导致编译出错：
Array a = 5；
我们只能使用
Array a(5);
进行显式初始化。
下面用一个例子来区别显式转型和隐式转型的细微区别：
X x;
Y y(x); //显式转型
Y y = x;//隐式转型
其中前者通过使用从X到Y类型的显式转型，新建一个类型为Y的对象。后者使用了一个从类型X到Y类型的隐式转型，新建了一个类型Y的对象。

3.在上述代码中，模板类Array的两个重载操作符operator[]代码：

T operator[](size_t indx) const
	{
		assert(indx < size());
		return expr_Rep[indx];
	}
T& operator[](size_t indx)
	{
		assert(indx < size());
		return expr_Rep[indx];
	}

 注意在一个重载操作符函数后面的const一定不能少，否则会导致编译错误。因为没有const的话，函数

T operator[](size_t indx)
	{
		assert(indx < size());
		return expr_Rep[indx];
	}

 和

T& operator[](size_t indx)
	{
		assert(indx < size());
		return expr_Rep[indx];
	}

会被认为是一个函数，因为他们静静是返回类型不同而已。函数
int test(){}
和
int test() const{}
会被编译器理解为两个不同的函数。

最后将SArray的代码附上:

#ifndef SARRAY_H
#define SARRAY_H

#include <stddef.h>
#include <cassert>

template<typename T>
class SArray
{
public:
	explicit SArray(size_t N):ptr(new T[N]),_size(N)
	{
		init();
	}
	SArray(SArray<T> const& orig):ptr(new T[orig.size()]),_size(orig.size())
	{
		copy(orig);
	}
	~SArray()
	{
		delete[] ptr;
	}
	size_t size() const
	{
		return _size;
	}
	T operator[](size_t indx) const
	{
		return ptr[indx];
	}
	T& operator[](size_t indx)
	{
		return ptr[indx];
	}
	SArray<T>& operator=(SArray<T> const& orig)
	{
		if (&orig != this)
		{
			copy(orig);
		}
		return *this;
	}
protected:
	void copy(SArray<T> const& orig)
	{
		assert(size() == orig.size());
		for (size_t indx=0;indx<orig.size();indx++)
		{
			ptr[indx] = orig[indx];
		}
	}
	void init()
	{
		for(size_t i=0;i<size();i++)
		{
			ptr[i] = T();
		}
	}
private:
	T* ptr;
	size_t _size;
};
#endif