Effective C++: lambda表达式与闭包.

最新推荐文章于 2024-02-19 15:21:12 发布

weixin_34246551

最新推荐文章于 2024-02-19 15:21:12 发布

阅读量136

点赞数

文章标签： c/c++ python javascript ViewUI

原文链接：https://my.oschina.net/SHIHUAMarryMe/blog/669919

版权

2019独角兽企业重金招聘Python工程师标准>>>

C++11:带来了lambda表达式.那么让我们一起来探究吧.

lambda捕获列表:

1, [] 空的捕获列表，lambda不能使用所在函数内的任何变量.

2, [names] names是一个用逗号分隔的名字列表，这些名字都是lambda所在函数的局部变量,默认情况都是以拷贝的性质捕获(capture)的，如果这些名字前面都有&那么就都是以引用的形式捕获的.

3, [&] 隐式的以引用形式的列表捕获，lambda体内所有的来自函数的实体都是以引用的形式捕获.

4, [=] 隐式的以拷贝形式的列表捕获，lambda体内的所有来自函数的实体都是以值的形式捕获的.

5, [&, names] names是一个逗号分隔的名字列表，包含0个或多个来自函数的变量，这些变量都是以拷贝的形式被捕获的，names中变量的名字前面不能使用&. 那些没有出现在names中，却出现在了lambda函数体变量都是以引用的形式捕获的.

6, [=, names] names是一个逗号分隔的名字列表，这些名字都是lambda所在的函数的局部变量，且这些名字前面必须有&,列表内的变量都是以引用的形式捕获的，那些没有出现在names中，却出现在lambda函数体中的变量都是以拷贝的形式捕获的.

7, [name] name是一个变量的名字，以拷贝的形式捕获该变量.

8, [&name] name是一个变量的名字，以引用的形式捕获该变量.

9, [this] this就是在一个类内捕获指向该类的指针以拷贝的形式捕获.

lambda的性质:

lambda没有固定的类型只能通过decltype来推断,标准规定lambda没有具体的类型,不是union,不是聚合类型，不是pr,不是某些特定类型的operator().

lambda的闭包特性:

Lambda表达式则是C++中的新语法，但是并没有许多程序员渴望的部分闭包特性（由于RAII的缘故）。C++中Lambda表达式可以被视为一种匿名函数，这样，对于一些非常短，而且不太可能被其他地方的复用的小函数，可以通过Lambda表达式提高代码的可读性。

　　在Lambda表达式中对于变量生命期的控制还是与完全支持闭包的JavaScript非常不同，总而言之，C++对于变量声明期的控制在新标准中完全向前兼容，也就是局部变量一定在退出代码块时被销毁，而不是观察其是否被引用。因此，尽管C++的Lambda表达式中允许引用其代码上下文中的值，但是实际上并不能够保证引用的对象一定没有被销毁。

　　Lambda表达式对于上下文变量的引用有值传递和引用传递两种方式，实际上，无论是哪种方式，在产生Lambda表达式对象时，这些上下文值就已经从属于Lambda表达式对象了，也就是说，代码运行至定义Lambda表达式处时，通过值传递方式访问的上下文变量值已经被写入Lambda表达式的栈中，而引用方式传递的上下文变量地址被写入Lambda表达式的栈中。因此，调用Lambda表达式时得到的上下文变量值就是定义Lambda表达式时这些变量的值，而引用的上下文变量，如果已经被销毁，则会出现运行时异常

#include <iostream>
#include <vector>
#include <functional>
#include <memory>

std::vector<std::function<void(const int&)>> filter;

class Widget{
 private:
  int divisor;
  
  public:
   Widget(const int& number=20):divisor(number){};
   
   ~Widget(){ std::cout<<"destroy!"<<std::endl; };
   
   void addFilter()const noexcept;
};

void Widget::addFilter()const noexcept
{
 auto ptr = this;
 auto n1 = 10;
 auto n2 = 20;
 filter.emplace_back([this](const int& value){ std::cout<<value<<"  "<<this->divisor<<std::endl; });
 //filter.emplace_back([ptr](const int& value){ std::cout<<value<<"  "<<ptr->divisor<<std::endl; }); //跟上面的效果实际上是一样的. 
 
 filter.emplace_back([&](const int& value){ std::cout<<n1<<" "<<n2<<std::endl; });
 filter.emplace_back([=](const int& vale){ std::cout<<n1<<" "<<n2<<std::endl; });
 
}

void addFilter()noexcept
{
 std::shared_ptr<Widget> ptr = std::make_shared<Widget>();
 ptr->addFilter();
}

int main()
{
 addFilter();
 
 //case 1:
 (filter[0])(20);
 
 //case 2:
 (filter[1])(30); //产生未定义行为：因为引用的n1和n2在函数addFilter()结束的时候被销毁了.
 
 //case 3:
 (filter[2])(40); //OK, 因为是拷贝的形式. 
  
  //case 4:
 int n1 = 1;
 auto f0 = [&n1]() { n1+=10; };
 f0();
 std::cout<<n1<<std::endl; //输出：11. 
 
 //case 5:
 int n2 = 2;
 std::function<int()> f1 = [&n2]()->int { n2+=10; std::cout<<"enter!"<<std::endl; return n2; };
 std::cout<<f1()<<"  "<<n2<<std::endl; //输出: 12  2; 
  //之所以会这样是因为 相当于std::cout<< (n2 += 10) << n2 << std::endl; 这是未定义的行为
 
 //case 6:
 int n3 = 3;
 std::function<int()> f2 = [&n3]()->int { n3+=10; return n3; };
 f2();
 std::cout<<n3<<std::endl; //输出: 13; 
 
 //case 7:
 int n4 = 4;
 std::function<int()> f3 = [n4]()mutable->int { n4+=10; return n4; }; //这里必须用mutable才能修改拷贝捕获过来的变量.
 f3();                                                     
 std::cout<<f3()<<" " <<n4<<std::endl; //输出: 24 2; 由此可以看出lambda是一个状态机. 
 
 //case 8:
 int n5 = 5;
 auto f4 = [n5]()mutable->int { n5+=10; return n5; };
 f4();                                
 std::cout<<f4()<<" "<<n5<<std::endl; // 输出: 25 5; 再次看出lambda是个状态机. 
 
 //case 9:
 std::unique_ptr<int> ptr(new int(300));
 auto f5 = [ptr = std::move(ptr)]() { std::cout<<*ptr<<std::endl; }; //dev c++下只能用 auto. 
 //std::function<void()> f5 = [ptr = std::move(ptr)](){ std::cout << *ptr << std::endl; }; //vs和dev c++都不能用. 
 f5(); //输出: 300; 
 
 return 0;
}

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/669919