首页 > 代码库 > C++的拖延战术：lazy evaluation

C++的拖延战术：lazy evaluation

2024-08-07 03:53:19   221人阅读

在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的值被改变亦是如此）。

Final Words：

缓式评估带来的好处对于整个程序而言可能有很大的冲击，所以在编写代码时：请谨记“不要付出任何额外的代价”，任何操作不必急着做，因为有可能这些操作永远都不会被执行。

Lazy 在此时最大的优点便是这些操作对用户而言是完全透明的。不必更改客户端的代码便可以取得性能的大幅提升。

C++的拖延战术：lazy evaluation


联系
我们