出处:http://www.cnblogs.com/liyiwen
本文版权归作者和博客园共有,欢迎转载,但请保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
在上篇里,我们看到了 (N)RVO 和右值引用,下面我们来看看表达式模板。
Expression Template(表达式模板,ET)
如果有“系统地”学习过 C++ 的模板编程,那么你应该已经知道 Expression Template 这个“东西”。在模板圣经《C++ templates》的第 18 章专门用了一整章来讲这个技巧,(是的,我认为它是一种技巧)。足以见得它比较复杂,也很重要。
说起 Expression Template 产生,“临时对象”也是“功臣”之一啊。还是来用例子来说明(你能很容易找到这样类似的例子,呵,我就是参照着别人写的):
class MyVec { public:MyVec(){p = new int[SIZE];}MyVec(MyVec const& a_left) {p = new int[SIZE];memcpy(p, a_left.p, SIZE * sizeof(int));}~MyVec(){delete [] p;}MyVec& operator=(MyVec const& a_left) {if (this != &a_left) {delete [] p;p = new int[SIZE];memcpy(p, a_left.p, SIZE * sizeof(int));}return *this;}int& operator [](size_t a_idx) { return p[a_idx];}int operator [](size_t a_idx)const { return p[a_idx];}MyVec const operator + (MyVec const& a_left) const {MyVec temp(*this);temp += a_left;return temp;}MyVec& operator += (MyVec const& a_left) { for (size_t i = 0; i < SIZE; ++i) {p[i] += a_left.p[i];}return *this;} private:static int const SIZE = 100;int* p; };int main(int argc, char* argv[]) {MyVec a, b, c;MyVec d = a + b + c;return 0; }
看,我们写下这么小段代码:
MyVec d = a + b + c;
这是很常用的数学运算吧,而且代码很直观。但这个表达式有一个问题,就是产生了“不必要”的临时对象。因为 a + b 的结果会成为一个存在一个临时对象上 temp 上,然后这个 temp 再加上 c ,最后把结果传给 d 进行初始化。如果这些向量很长,或是表达式再加几节,可以想像这些 temp 会多让人不爽。
而且,如果我们写成这样:
MyVec d = a;
d += b;
d += c;
就可以避免产生多余的临时对象。但这样写,如果是不了解“行情”的人看了MyVec d = a + b + c;之后再看这段,是不是会觉得写这代码的人欠K?
好吧,你会问,上面不是说右值引用可以解决这样问题?是的,但在没有右值引用的“黑暗日子”里,我们就不用过活了?当然要,小学开始数学老师就教我们要一题多解吧,换个思路也有办法,这个办法就是ET。
怎么做的呢?a + b + c 会产生临时变量是因为 C++ 是即时求值的,在看到 a + b,就先算出一个 temp 的Vector对象,然后再向下算。如果能进行延迟求值,看完整个表达式再来计算,那么就可以避免这个temp的产生。
怎么做?
原来的做法中,operator + 直接进行了计算,既然我们不想它“过早”的计算,那么我们就在重新重载一个operator + 运算符,在这个运算中不进行真正的运算,只是生成一个对象,在这个对象中把加法运算符两边的操作数保留下来~然后让它参与到下一步的计算中去。(好吧,这个对象也是临时的,但它的代价非常非常小,我们先不理会它)。于是我们写下面的代码:
class MyVec;template <typename L> class ExpPlus {L const & lvec;MyVec const & rvec; public:ExpPlus(L const& a_l, MyVec const& a_r):lvec(a_l), rvec(a_r){ }int operator [] (size_t a_idx) const; };// Point 1 template <typename L> ExpPlus<L> operator + (L const& a_l, MyVec const & a_r) {return ExpPlus<L>(a_l, a_r); }class MyVec { public:MyVec(){p = new int[SIZE];}MyVec(MyVec const& a_r) {p = new int[SIZE];memcpy(p, a_r.p, SIZE * sizeof(int));}template <typename Exp>MyVec(Exp const& a_r) {p = new int[SIZE];for (size_t i = 0; i < SIZE; ++i) {p[i] += a_r[i];}}~MyVec(){delete [] p;}MyVec& operator = (MyVec const& a_r) {if (this != &a_r) {delete [] p;p = new int[SIZE];memcpy(p, a_r.p, SIZE * sizeof(int));}return *this;}template <typename Exp>MyVec& operator = (Exp const & a_r) {delete [] p;p = new int[SIZE];for (size_t i = 0; i < SIZE; ++i) {p[i] += a_r[i];}return *this;}int& operator [](size_t a_idx) { return p[a_idx];}int operator [](size_t a_idx)const { return p[a_idx];} private:static int const SIZE = 100;int* p; };template <typename L> int ExpPlus<L>::operator [] (size_t a_idx) const {return lvec[a_idx] + rvec[a_idx]; }int main(int argc, char* argv[]) {MyVec a, b, c;MyVec d = a + b + c;return 0; }
比起之前的代码来说,这段代码有几个重要的修改:首先,我们增加了一个模板类 ExpPlus,用它来代表加法计算的“表达式”,但在进行加法时,它本身并不进行真正的计算。对这个类,定义了下标运算符,这个运算符中才进行了真正的加法计算。然后,对于原来的 MyVec,我们重载它的赋值运算符,让它在赋值的时候通过ExpPlus的下标运算符来获得计算结果(也就是,在赋值操作时才真正的进行了计算!)。
上面这段话,对于不了解ET的人来说,也许一时间还不容易明白,我们一步一步来:
在 d = a + b + c 这个式子中,首先遇到 a + b,这时,模板函数 operator + 会被调用(代码中注释了“Point 1 ”),这时只是生成一个临时的ExpPlus
最后,当进行 d = t2 的时候,MyVec 的赋值运算符被调用(用 t2 作参数)。注意,这个调用中的语句 p[i] = t2[i],其中 t2[i] 通过重载的下标运算符,展开成 t1[i] + c[i],同理 t1[i] 又再次展开,成为 a[i]+b[i],最终,p[i] = t2[i] 就变成了:p[i] = a[i] + b[i] + c[i])(当然,里面参杂了内联的效果,这些函数都是非常容易被内联的)。就像变“魔术”一样,我们通过ExpPlus完成了“延迟计算”,并避免了大型的 MyVec 临时对象的产生。
这基本上就是 ET 的“原理”了吧。我们来“专门化”一下 ET 的好处:
- To create a domain-specific embedded language (DSEL) in C++
- To support lazy evaluation of C++ expressions (e.g., mathematical expressions), which can be executed much later in the program from the point of their definition.
- To pass an expression — not the result of the expression — as a parameter to a function.
这样,用 ET 就能兼顾到“直观”和“效率”了。
ET 中 C++ 中的类库里已经有非常多的应用了(包括 boost 中的多个子库,以及 Blitz++ 等高性能数学库)
总结
(N)RVO 是编译器为我们做的优化手段,在能进行优化的情况下,NRVO 的表现是非常好的,因为它才真正的避免了临时对象的产生(rvalue reference 和 expression template 中都可能还存在一些小型临时对象),但 (N)RVO 有很多的限制条件。右值引用(rvalue reference )和 move 语意弥补了 (N)RVO 的不足之处,使得临时对象的开销最小化成为可能,但这也是有局限的,比如,嗯,如果一个类本身不动态地拥有资源……,那 move 就没有意义了。Expression Template 保持了表达式直观和效率两者,很强大,但很显然它太复杂,主要是作为类库的设计者的武器。另外,它也可能使得使用者要理解一些“新”东西,比如,如果我想存储表达式的中间值,那么
全文完!