在C++中这里的拖延战术拥有一个非常优雅的名字 －－ Lazy evalution。一旦你的程序中使用了lazy evaluation，那么你就可以在你实际需要某些动作时编写相应的代码，如果不需要，那么相应的动作也就永远都不会执行。
那么我们在什么时候会用的上这样的技术呢？
Reference Counting 引用计数
对于引用技术，相信大部分人都不觉得陌生，在C++中的智能指针shared_ptr便是利用这一技术的最佳人选。下面要讲的是C++的string类的实现，string类的实现（可能有些库并未采用lazy evaluation的技术）同样采用了引用计数，比如下面是我们经常会遇到的代码：
1 2 3 |
class string {....};
string s1 = "Hexo";
string s2 = s1;
|
关于 string s2 ＝ s1的行为，其实取决于string类的copy ctor的实现方式，如果string类采用的时eager evaluation的方式，这就意味着，当s2被创建的时候，copy ctor负责为s2分配内存空间，并且拷贝s1的内容到s2的内存中。设想一下，如果s2的值并未被使用或者是在之后的语句中对于s2只是读取，并未修改，那么上述的copy
ctor的工作便是白白浪费掉了的。如果在一个程序中大量出现这样的对象的创建，那么对于整个程序的冲击无疑时很大的。
此时，lazy evaluation可以省去上述的很多工作，因为此时s2与s1共享同一块内存空间，直到不得不分配自己的空间时。这个过程省去了“分配内存”以及“字符串拷贝”的工作，只需要做一些简单的记录，表示当前s2与s1共享的是同一块内存空间即可。当然，这整个过程对于用户来说则是透明的。比如下面的读取操作：
1 2 |
cout << s1 << " " << s2 << endl; cout << s1 + s2 << endl; |
这样的共享直到某个不得已的瞬间出现，即其中的任何一个字符串发生改变的时候，比如：
1 |
s1.toLowerCase(); //将s1中的所有的字母都变为小写 |
上述代码的意图是修改s1的内容，但是现在s1与s2共享的是同一块内存空间，那么此时就需要为s2分配空间，并且复制字符串的内容。如果整个过程都没有出现字符串被修改的操作，那么lazy evaluation便做到了不必为你不需要的操作付出任何的代价。
其实这就是C++的string的COW（copy on write）的技术。大部分的程序库现在都使用的是cow的技术，顺带一提，这样的计数是线程不安全的。
区分读和写
继续上面的string类，对于下面的代码：
1 2 3 |
string s = "Hello"; cout << s[3]; //仅仅只是读取 s[3] = ‘x ; |
上述两句都是对operator[]的调用，我们希望区分上述两种语句，读或者写，因为如果是读，那么我们还可以更lazy一点，直到写时再分配内存以及复制内存。编译器如何区分呢？很无奈，编译器做不到，我们可以使用代理类的技术来实现区分。
Lazy Fetching 缓式取出
假设程序中使用了大型对象，其内部还有很多不同的字段，假设我们需要从一个很大的数据库中去读取对象的内容，假设对象很大，那么我们在需要某个对象时，不是直接将该对象完全读入之后，再读取需要的字段，而是在需要某个字段的时候再去读取该对象的相应字段即可。例如下面的一个简单的类；
1 2 3 4 5 6 7 8 9 |
struct Type1 {...};
struct Type2 {...};
struct Type3 {...};
class LargeStruct
{
Type1 mem1;
Type2 mem2;
Type3 mem3;
};
|
现在我有一个本地的read函数，需要读取mem1字段，如：
1 2 3 4 5 6 7 8 9 |
void readmem1(const char *arg)
{
LargeStruct big(arg); //这里的参数arg作为在远端读取数据的凭证
if(big.mem1 == 0)
{
//do something
}
return;
}
|
那么上述的代码中只需要访问到big对象的mem1字段，但是我们却需要构造出整个对象，这无疑是对资源的一大浪费，设想一下，如果数据存储在远端的服务器，那么每次拷贝一个LargeStruct的对象，无疑是对网络带宽的一大浪费，显然，Lazy Fetching在这里意味着 提供给你的资源绝对不要超出你想要的范围，否则就是浪费。
那么，像上述这样的类，本地应该如何定义，才能使用Lazy evaluation。也就是说Lazy Fetching的技术如何实现呢，其实很简单，定义一个指针的类，也就是说上述的mem1，mem2，mem3不是直接作为对象放在类中，而是使用指针。（这里其实很容易想到，比如我们不需要该成员时，只需要将成员置为空，并且不会调用该成员的任何构造函数，直到需要时，才构造该成员变量的对象即可）。
1 2 3 4 5 6 7 8 9 10 11 |
struct Type1 {...};
struct Type2 {...};
struct Type3 {...};
class LargeStruct
{
Type1 *mem1;
Type2 *mem2;
Type3 *mem3;
LargeStruct(Type1 *_mem1=nullptr, Type2 *_mem2=nullptr, Type3 *_mem3=nullptr):
mem(_mem1),mem2(_mem2,mem3(_mem3){}
};
|
只有在真正需要某个成员的时候，才会将该指针赋值，如果是在const成员函数中，怎么改变成员变量呢，请参考 XXXX
表达式缓评估
矩阵运算是一个非常好的例子，比如：A B是两个1000*1000的矩阵：
1 2 3 4 |
matrix A(1000,1000), B(1000,1000); matrix C = A + B; //这里先不必急着计算C的值。 ... //此处的代码中并未使用C的值，又或者是改变了C的值。 C ＝ A＋ A; // C的值又被改变了，上面的A＋B的值，我们还没计算呢，那就不必计算了。节约了资源，不是吗？ |
对于上述这样的代码，程序员的不经意的语句将导致 100万的数字的计算，计算成本是相当大的。
还有一个值得称颂的点，是部分值，也就是说我们只需要使用结果矩阵的部分值：
比如：
1 2 3 |
matrix A(1000,1000), B(1000,1000); matrix C = A + B; //这里先不必急着计算C的值。 cout << C[4] ; // 这里只需要第4行的数据，那么只计算第4行即可。 |
那么我们究竟有多幸运，使得我们不需要计算整个矩阵的值呢，其实概率是很大的，矩阵运算大部分都是采用了这样的懒惰政策，大大节省了时间与资源，但是在下面的情况下，幸运就不会再出现了：
1 2 |
cout << C ; //需要打印整个矩阵的值， B ＝ D； //B被改变了。那么上述的C ＝ A＋B的值，此时就必须计算C的所有的元素，因为B的值被改变了。（A的值被改变亦是如此）。 |