c++11实现l延迟调用（惰性求值）

惰性求值

惰性求值一般用于函数式编程语言中，在使用延迟求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在后面的某个时候求值。 
    可以利用c++11中的std::function， lambda表达式以及c++11实现的Optional来实现lazy。其中,std::function用来保存传入的函数，不马上执行，而是延迟到后面需要使用值的时候才执行，函数的返回值被放到一个Optional对象中（可以更方便的知道是否求值完毕，使用起来更方便）。通过optional对象可以知道是否已经求值，当发现已经求值的时候直接返回之前计算的结果，起到了缓存的作用。

c++11实现延迟（惰性）求值【代码均参考网上】

(1) Optional.hpp

//Optional.hpp 实现 Optional
#include<type_traits>
#include<iostream>
#include<string>
#include<map>
using namespace std;
template<typename T>
class Optional
{
	using data_t = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
public:
	Optional() : m_hasInit(false) {}
	Optional(const T& v)
	{
		Create(v);
	}

	Optional(T&& v) : m_hasInit(false)
	{
		Create(std::move(v));
	}

	~Optional()
	{
		Destroy();
	}

	Optional(const Optional& other) : m_hasInit(false)
	{
		if (other.IsInit())
			Assign(other);
	}

	Optional(Optional&& other) : m_hasInit(false)
	{
		if (other.IsInit())
		{
			Assign(std::move(other));
			other.Destroy();
		}
	}

	Optional& operator=(Optional &&other)
	{
		Assign(std::move(other));
		return *this;
	}

	Optional& operator=(const Optional &other)
	{
		Assign(other);
		return *this;
	}

	template<class... Args>
	void emplace(Args&&... args)
	{
		Destroy();
		Create(std::forward<Args>(args)...);
	}

	bool IsInit() const { return m_hasInit; }

	explicit operator bool() const {
		return IsInit();

	}

	T& operator*()
	{
		if (IsInit())
		{
			return *((T*)(&m_data));
		}

		throw std::logic_error("is not init");
	}

	T const& operator*() const
	{
		if (IsInit())
		{
			return *((T*)(&m_data));
		}

		throw std::logic_error("is not init");
	}

	bool operator == (const Optional<T>& rhs) const
	{
		return (!bool(*this)) != (!rhs) ? false : (!bool(*this) ? true : (*(*this)) == (*rhs));
	}

	bool operator < (const Optional<T>& rhs) const
	{
		return !rhs ? false : (!bool(*this) ? true : (*(*this) < (*rhs)));
	}

	bool operator != (const Optional<T>& rhs)
	{
		return !(*this == (rhs));
	}
private:
	template<class... Args>
	void Create(Args&&... args)
	{
		new (&m_data) T(std::forward<Args>

			(args)...);
		m_hasInit = true;
	}

	void Destroy()
	{
		if (m_hasInit)
		{
			m_hasInit = false;
			((T*)(&m_data))->~T();
		}
	}

	void Assign(const Optional& other)
	{
		if (other.IsInit())
		{
			Copy(other.m_data);
			m_hasInit = true;
		}
		else
		{
			Destroy();
		}
	}

	void Assign(Optional&& other)
	{
		if (other.IsInit())
		{
			Move(std::move(other.m_data));
			m_hasInit = true;
			other.Destroy();
		}
		else
		{
			Destroy();
		}
	}

	void Move(data_t&& val)
	{
		Destroy();
		new (&m_data) T(std::move(*((T*)

			(&val))));
	}

	void Copy(const data_t& val)
	{
		Destroy();
		new (&m_data) T(*((T*)(&val)));
	}

private:
	bool m_hasInit;
	data_t m_data;
};

 (2) Lazy.cpp

#include"Optional.hpp"
#include<memory>
#include<functional>
template<typename T>
struct Lazy{
	Lazy(){};
	//保存需要延迟执行的函数
	template<typename Func, typename ...Args>
	Lazy(Func& f, Args&&... args){ //给出需要调用的函数和参数，封装起来。等待之后被调用
		m_func = [&f, &args...]{return f(args...); };
	}
	//延迟执行，将结果放到optional中缓存起来，下次不用重新计算可以直接得到结果
	T& Value(){
		if (!m_value.IsInit()){
			m_value = m_func();
		}
		return *m_value;
	}

	bool IsValueCreated()const{
		return m_value.IsInit();
	}
private:
	std::function<T()> m_func;		//返回值类型为T的无参可调用对象 m_func
	Optional<T> m_value;
};

//定义一个模板函数，返回值类型为 Lazy
template<class Func, typename... Args>
Lazy<typename std::result_of<Func(Args...)>::type> lazy(Func&& fun, Args&& ...args){
	return Lazy<typename std::result_of<Func(Args...)>::type>(std::forward<Func>(fun), std::forward<Args>(args)...);
}

struct BigObject{
	BigObject(){
		cout << "lazy load big object" << endl;
	}
};

struct MyStruct{
	MyStruct(){
		m_obj = lazy([]{return std::make_shared<BigObject>(); });
	}
	void Load(){
		m_obj.Value();
	}
	Lazy<std::shared_ptr<BigObject>> m_obj;
};

int Foo(int x){
	return x * 2;
}

void TestLazy(){

	//带参数的普通函数
	int y = 4;
	auto lazyer1 = lazy(Foo, y);
	cout << lazyer1.Value() << endl;

	//不带参数的lambda
	Lazy<int> lazyer2 = lazy([]{return 12; });
	cout << lazyer2.Value() << endl;

	//带参数的function
	std::function<int(int)> f = [](int x){return x + 3; };
	auto lazyer3 = lazy(f, 3);
	cout << lazyer3.Value() << endl;

	//延迟加载大对象
	MyStruct t;
	t.Load();
}

int main(){
	TestLazy();
	return 0;
}