惰性求值

惰性求值一般用于函数式编程语言中,在使用延迟求值的时候,表达式不在它被绑定到变量之后就立即求值,而是在后面的某个时候求值。 
    可以利用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. 【C#】遍历List列表的同时,移除访问到的元素

    需求:遍历List列表,当访问的元素符合某一条件时,将该元素移除出列表. 注意点:使用foreach循环遍历无法做到边读边修改,所以要使用for循环. 例子: // 倒序遍历. for (int i ...

  2. 【转】【Unity】DateTime各种时间字符串

    各种表示时间的方法 谢谢网络上的大神 此片为转载的文章 DateTime.Now.ToShortTimeString() DateTime dt = DateTime.Now; dt.ToString ...

  3. Extjs Ext.ux.IFrame的用法 以及父子窗口间函数相互调用

    Extjs Ext.ux.IFrame的用法 以及父子窗口间函数相互调用 Ext.ux.IFrame Extjs官方提供的一个组件,可以很方便的使用. 这样就完成了一个简单的IFrame的使用,通过E ...

  4. mysql查看表结构

    SELECT COLUMN_NAME,DATA_TYPE,COLUMN_COMMENT from information_schema.COLUMNS where TABLE_SCHEMA='ceco ...

  5. Zookeeper CLI

    ZooKeeper命令行界面(CLI)用于与ZooKeeper集合进行交互以进行开发.它有助于调试和解决不同的选项. 要执行ZooKeeper CLI操作,首先打开ZooKeeper服务器(“bin/ ...

  6. CentOS下的一些基础问题解答

    1. 在/etc/passwd中某一行信息为“Linux01:x:505:505:/home/linux12:/bin/bash”,由此可知哪些信息? 用户名为linux01,需要密码登陆,用户ID为 ...

  7. myslq的索引类型为MyISAM和BDB的表:复合索引下的自增长

    本文源自:http://www.himigame.com/mysql/781.html 3.6.9. 使用AUTO_INCREMENT 可以通过AUTO_INCREMENT属性为新的行产生唯一的标识: ...

  8. list模块

    一.   concat(Things) -> string() Types:    Things = [Thing]    Thing = atom() | integer() | float( ...

  9. Linux基础知识之history的详细说明

    背景:history是Linux中常会用到内容,在工作中一些用户会突然发现其安装不了某个软件,于是寻求运维人员的帮助,而不给你说明他到底做了哪些坑爹的操作.此时你第一件要做的就是要查看其history ...

  10. c#后台访问接口

    直接上代码 后台代码 //接口地址string url = "http://spherefg.topsmoon.com:6666/restapi/Comment/SubmitCommentF ...