惰性求值

惰性求值一般用于函数式编程语言中,在使用延迟求值的时候,表达式不在它被绑定到变量之后就立即求值,而是在后面的某个时候求值。 
    可以利用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;
}

c++11实现l延迟调用(惰性求值)的更多相关文章

  1. Stream01 定义、迭代、操作、惰性求值、创建流、并行流、收集器、stream运行机制

    1 Stream Stream 是 Java 8 提供的一系列对可迭代元素处理的优化方案,使用 Stream 可以大大减少代码量,提高代码的可读性并且使代码更易并行. 2 迭代 2.1 需求 随机创建 ...

  2. C#函数式编程之惰性求值

    惰性求值 在开始介绍今天要讲的知识之前,我们想要理解严格求值策略和非严格求值策略之间的区别,这样我们才能够深有体会的明白为什么需要利用这个技术.首先需要说明的是C#语言小部分采用了非严格求值策略,大部 ...

  3. 惰性求值——lodash源码解读

    前言 lodash受欢迎的一个原因,是其优异的计算性能.而其性能能有这么突出的表现,很大部分就来源于其使用的算法--惰性求值. 本文将讲述lodash源码中,惰性求值的原理和实现. 一.惰性求值的原理 ...

  4. GString惰性求值

    当对一个GString实例求值时,如果其中包含一个变量,该变量的值会被简单地打印到一个Writer,通常是一个StringWriter.然而,如果GString中包含的是一个闭包,而非变量,该闭包就会 ...

  5. C++11新特性应用--实现延时求值(std::function和std::bind)

    说是延时求值,注意还是想搞一搞std::function和std::bind. 之前博客<C++11新特性之std::function>注意是std::function怎样实现回调函数. ...

  6. python 惰性求值 https://blog.csdn.net/Appleyk/article/details/77334221

    为什么调用的不是同一个函数呢 是因为调用函数后,函数的生命周期就结束了,再调用就是另一个函数了

  7. 《EOPL》: 实现了惰性求值的两种参数传递策略

    call-by-need 不过是比 call-by-name 多了一个 memorization 的步骤

  8. [SICP] 求值规则

    在Java语言学习中,通常不太关注求值规则. (2+4*6)*(3+5+7)这样的组合式的求值规则.通常归结为优先级问题: if.for等的求值规则通常归结为语义. 函数式编程语言的Scheme,将这 ...

  9. 编写高质量代码改善C#程序的157个建议——建议28:理解延迟求值和主动求值之间的区别

    建议28:理解延迟求值和主动求值之间的区别 要理解延迟求值(lazy evaluation)和主动求值(eager evaluation),先看个例子: List<, , , , , , , , ...

随机推荐

  1. DevExpress gridcontrol学习知识点

    .//允许自动合并单元格gv1.OptionsView.AllowCellMerge = true; 设置某列不合并 选中该列,在OptionsColumns-->AllowMerge中设置为f ...

  2. PHP程序员的10个有用的技巧和教程

    PHP被定义为一个通用的服务器端脚本语言,它基本上是专为Web开发的重要目的.借助PHP可以创建动态和惊人的网页效果,他是被嵌入在一个HTML源文件的服务器端的脚本语言之一.因此,它成为最流行的,也是 ...

  3. PHP 初学之登录查询小case

    说明:如误入本文,请忽略即可,内容仅为记录. 功能:登录(不验证),查询所有列表,删除记录.--很简单,仅为熟悉代码. // MySQL,新建数据库data,导入如下sql ; -- -------- ...

  4. error: expected declaration specifiers or '...' before 'xxxx'(xxxx是函数形参)

    今天汗颜了一大阵 早上,在编译我的源代码的时候竟然不通过编译,上个星期六也出现了这种情况,当时不知道怎么弄的后来又通过编译了,可能是原来的.o文件没有make clean 还保存在那里,以至于蒙过去了 ...

  5. CentOS查看本机公网IP命令

    icanhazip.com 使你在任何地方知道你的公网IP地址 icanhazip.com是一个网址,你在浏览器中输入这个网址,你就能得到你的公网IP地址了. 我在Linux下一般使用curl ica ...

  6. wcf实体和ef实体冲突。。。

    指定的架构无效.错误: CLR 类型到 EDM 类型的映射不明确,因为多个 CLR 类型与 EDM 类型“agentinfo”匹配.以前找到的是 CLR 类型“chanchengFlow.Models ...

  7. python3.4连接mysql

    参考:http://www.blogjava.net/huyi2006/articles/247966.html 开发环境:win7_x64 + python3.4.3 + mysql5.6.23 准 ...

  8. [mysql] 查询前几条记录

    From: http://www.cnblogs.com/xuxm2007/archive/2010/11/16/1878211.html SELECT   *   FROM   table   LI ...

  9. ThinkPHP导出CSV、Excel

    Thinkphp/Library/Think下新文件文件:Csv.class.php <?php namespace Think; class Csv { //导出csv文件 public fu ...

  10. Windows7下4种方式快速显示桌面

    1.Windows键+D快捷键直接显示桌面: 2.鼠标移到任务栏右下角直接显示桌面: 3.Windows键+空格快捷键显示桌面: 4.任务栏鼠标右键,选择“显示桌面”.