一、Lazy evaluation
惰性加载或者延迟计算，在前面的文章《跟我学c++中级篇——迟延计算》中分析过。叫法怎么叫都可以，只要大家明白这个意思即可。Lazy evaluation一般可用于下面的情况：
1、模板中的对象非立刻的模板实例化，也就是说有的类很大，其实有些类在初始化并用不到，只有在实现具体功能时，才用得到。而如果恰好这些对象又比较耗资源，用到的可能性又不是多大时，惰性加载的优势便体现了出来。
2、函数功能的分发延迟，其实就是函数对象的延迟调用。
3、元编程或者模板编程的计算延迟，比如在求类似数列求和、递归计算等中都有体现。
内核中使用的COW这种技术，其实就可以认为是一种延迟加载。
二、作用
计算机技术发展到现在，本质上还是资源的抢夺，只要无法解决这个问题，各种资源管理技术仍然会不断出现。所以延迟加载带来的好处就是：
1、提高了性能，无论减少实例化还是在编译期实现计算都提高了程序的处理速度，提高了性能。
2、对计算机资源，特别是内存的耗用减少。
3、类似于函数编程，更容易进行并行计算处理。
4、有利用于在复杂情况下维护和异常分析，比如设计某些计算会在什么状态下才会启动，那么之前的异常分析中，就不用考虑这一部分了。
5、如《c++模板元编程》中提到的，减少编译时间，提供安全性，通过定义无效的计算而不去执行。
在c++中实现延迟加载可以使用下的几种方式：
1、前面提到过的增加一个外覆器，不对外暴露相关类型、结果等。模板就不会主动去实例化，从而达到延迟加载的目的。
2、使用一些基本的控制，比如把运行期的if条件语句转到编译期一些if_函数系列，则就可以导致惰性加载。
3、封装一些函数和运算子的对象化，这和1原理基本相同。
在实际编程可以经常用到的有c++11中的std::function， lambda表达式以及c++11和std::Optional等来实现。
三、例程
这里看一下相关的应用例程：
#include <iostream>
template<typename T, bool have>
struct Ex
{
static T* getins(const T* ins)
{
if (have)
{
return ins->max();
}
else
{
return new T(* ins);
}
}
};
struct NoMax
{
NoMax() {}
NoMax(const NoMax&) {}
};
Ex<NoMax, false> instance; //lazy
int main()
{
NoMax nm;
//NoMax* newObject = instance.getins(&nm);//error
}
上面注释的代码就是想窥探模板实现的内部数据了，就报一个错误，否则只是给一个外部类的实现就不会有问题。再看一个函数延迟加载的：
#include <tuple>
#include <iostream>
template <typename Func, typename... Args>
class LazyFunc
{
private:
Func func;
std::tuple<Args...> args;
using invoke = std::invoke_result_t<Func, Args...>;
public:
LazyFunc(Func f, Args... a)
: func(f)
, args{ a... }
{
}
operator invoke()
{
return std::apply(func, args);
}
};
//定义推导规则 c++17以后可忽略
template <typename Func, typename... Args>
LazyFunc(Func, Args...)->LazyFunc<Func, Args...>;
int Sub(int a, int b)
{
std::cout << "start sub..." << std::endl;
return a - b;
}
int main()
{
auto result = LazyFunc(Sub, 12, 11);
std::cout << "go ......" << std::endl;
std::cout << result << std::endl;
return 0;
}
这其实就是使用c++新标准来实现的，为了让延迟加载更能体现的清晰，可以继续在上面封装，这样就容易理解延迟加载。有兴趣可以自己试试。
四、元编程中的应用
弄清楚了上面的原理，再看一下在元编程的应用：
#include <type_traits>
template<typename T>
struct HaveEx
{
static T* getins(const T* ins)
{
return instance->max();
}
};
template<typename T>
struct NoHaveEx
{
static T* getins(const T* ins)
{
return new T(* ins);
}
};
template<typename T,bool ok>
using CT = std::conditional<ok, HaveEx<T>, NoHaveEx<T>>::type ;
int main()
{
CT<NoMax, false> ct;
NoMax * nn = ct.getins(&nm);
std::cout << typeid(CT<NoMax,false>).name() << '\n';
}
多写代码，好多东西自然就明白了，慢慢来。
五、总结
惰性加载或者缓式应用，这种技术的目的是什么一定要掌握，明白了其为什么出现，比会用更好。学习一门技术的应用基本上难不到大多数人，但对大多数人来说，如何掌握这其中的内在原理并灵活应用到其它一些类似的方向上，这才是更上一层。世界这么大，技术是无穷的，但原理却要少得多。越往后学，大家会发现，初学计算机时的那些原理反而越深刻的影响到自己。
如果始终觉察不到这一点，那就只能是那就了。