c++ 11 lambda 用法与原理

已于 2023-07-27 11:04:50 修改
阅读量983 收藏 3
点赞数 1
分类专栏： c++ 文章标签： c++ 开发语言
于 2022-05-27 22:21:22 首次发布
原文链接：https://mp.weixin.qq.com/s/oONwCjdrlMbgwMnUWQiLZw
版权

lambda也出现了好长时间，一直以来也仅仅限于使用，今天，借助此文，我们从使用、实现的角度聊聊lambda。

在开始正文之前，我们先看一个问题，对下面的vector进行排序：

std::vector<int> v = {1, 3, 2};

在C++11之前，我们可能会这么做(普通函数，即函数指针作为参数)：

bool Compare(int a, int b) {
  return a < b;
}

int main() {
  std::vector<int> v = {1, 3, 2};
  std::sort(v.begin(), v.end(), Compare);
  
  return 0;
}

也有可能这样做(函数对象，即类对象作为参数)：

int main() {
  struct Compare {
    bool operator()(int a, int b) {
      return a < b;
    }
  };
  std::vector<int> v = {1, 3, 2};
  std::sort(v.begin(), v.end(), Compare());

  return 0;
}

但是上述两种方式均有其局限性，对于普通函数的实现方式来说，其优点是具有最小的语法开销，缺点是不能限定作用域（即必须在使用作用域外进行定义），而对于函数对象的实现方式来说，其优点是可以在作用域内进行定义，但缺点是需要有类定义的语法开销。

既然函数指针和函数对象都有其优缺点，那么有没有其它方式既保持了二者的优点，又摒弃了二者的缺点呢？当然有了，这就是lambda。

本文的主要内容如下：

概念

自C++11开始，引入了lambda(一般称之为为lambda表达式)，一个lambda表达式表示一个可调用的代码单元。我们可以将其理解为一个匿名的内联函数。lambda表达式跟普通函数相比不需要定义函数名，取而代之的多了一对方括号[]。

先看下lambda的基本语法，如下：

[capture](parameters) specifiers exception attr -> return type { /*code; */ }

在上面定义中：

  • [capture]代表捕获列表，括号内为外部变量的传递方式，包括值传递、引用传递等

  • (parameters)代表参数列表，其中括号内为形参，和普通函数的形参一样

  • specifiers exception attr代表附加说明符，一般为mutable、noexcept等

  • ->return type代表lambda函数的返回类型如 -> int、-> string等。在大多数情况下不需要，因为编译器可以推导类型

  • {}内为函数主体，和普通函数一样

为了便于我们对lambda的使用有个初步认识，下面是一些常用的例子：

// 1. 最简单的lambda，没有任何行为操作:
[]{};

// 2. 包含两个参数的lambda:
[](float f, int a) { return a * f; };
[](int a, int b) { return a < b; };

// 3. 有返回值的lambda:
[](MyClass t) -> int { auto a = t.compute(); print(a); return a; };

// 4. 存在附加说明符的lambda:
[x](int a, int b) mutable { ++x; return a < b; };
[](float param) noexcept { return param*param; };
[x](int a, int b) mutable noexcept { ++x; return a < b; };

// 5. 参数列表可选：
[x] { std::cout << x; }; // 去掉()
[x] mutable { ++x; };    // 编译失败!
[x]() mutable { ++x; };  // 正常编译，这是因为在附加说明符前面需要有()
[] noexcept { };        // 编译失败!
[]() noexcept { };      // 正常编译，这是因为在附加说明符前面需要有()

好了，现在回到正题，如果我们使用lambda来实现之前排序的话，应该怎么做呢？如下：

int main() {
  std::vector<int> v = {1, 3, 2};
  std::sort(v.begin(), v.end(), [](int a, int b){
    return a < b;
  });
  return 0;
}

从上述实现可以看出，其相较于函数指针和函数对象的实现方式，更为简洁直观。

捕获列表

在上一节中，我们提到了lambda定义中的几个基本点：捕获列表、函数参数、附加说明符、返回类型以及函数体。函数参数、返回类型和函数体在普通函数或者类成员函数中我们都有用到，那么什么是捕获列表和附加说明符呢？这就是本节的内容。

捕获的作用是捕获lambda所在函数的局部变量（捕获全局变量或者静态变量编译器会报warning，后面有说明）。其中捕获的类型可以分为值捕获，引用捕获和隐式捕获：

  • 值捕获 与函数中的值传递类似。lambda表达式捕获的是变量的一个拷贝，因此我们如果在lambda表达式后面改变该变量值的话，不会影响捕获前的该变量值，这就是所谓的值捕获

    int a = 1;
[a](){printf("%d\n", a;);}

  • 引用捕获 引用捕获和值捕获形式完全一样，只是在捕获列表中传的是变量的引用，类似于函数中的引用传递，变成下面这个样子

    int a = 1;
[&a](){printf("%d\n", a;);}

  • 隐式捕获的方式，就是捕获的列表可以用=和&代替，让编译器隐式的推断你使用的是哪个变量，然后这两个字符表示捕获的类型=表示值捕获，&是引用捕获；写出来之后就变成了如下的形式：

    int a = 1;
[=](){printf("%d\n", a);};
[&](){printf("%d\n", a;);}

下面是捕获列表的一些语法规则：

  • [&]通过引用捕获作用域内的全部局部变量

  • [=]通过引用捕获作用域内的全部局部变量

  • [x, &y] x按照值捕获和y按照引用捕获。

  • [x = expr] 带有初始化表达式的捕获 (C++14)

  • [args...] 捕获模板参数包，全部按值。

  • [&args...] 捕获模板参数包，全部通过引用。

  • [...capturedArgs = std::move(args)](){} 通过移动操作符捕获包(C++20)

捕获规则示例代码如下：

int x = 2, y = 3;

const auto l1 = []() { return 1; };   // 没有捕获任何内容 
const auto l2 = [=]() { return x; };  // 按值捕获所有变量
const auto l3 = [&]() { return y; };  // 按引用捕获所有变量
const auto l4 = [x]() { return x; };  // 仅对x进行按值捕获
const auto l5 = [&y]() { return y; }; // 仅对y进行按引用捕获
const auto l6 = [x, &y]() { return x * y; }; // 对x按值捕获，对y按引用捕获
const auto l7 = [=, &x]() { return x + y; }; // 对x按引用捕获，其余的按值捕获
const auto l8 = [&, y]() { return x - y; };  // 对y按值捕获，其余的按引用捕获
const auto l9 = [this]() { } // 捕获this指针
const auto la = [*this]() { } // 按值捕获*this对象

值捕获

lambda表达式可以将作用域内的变量捕获到lambda函数中。在lambda的表达式定义中，我们有提到[=]指定可以按值捕获作用域内的任何变量，[x]则仅仅按值捕获变量x。

仅捕获某个变量，代码如下：

int main() {
  int x = 5;
  auto fun = [x]() { printf("%d\n", x); };
  fun();
  return 0;
}

捕获所有变量，代码如下：

int main() {
  int x = 5;
  int y = 6;
  auto fun = [=]() { printf("%d, %d\n", x, y); };
  fun();
  return 0;
}

引用捕获

可以使用引用捕获调用lambda表达式。当使用引用捕获时候，捕获的值实际上是对lambda外部范围内变量的引用。

int main() {
  int x = 5;
  auto fun = [&x]() { printf("%d\n", ++x); };
  fun();
  printf("%d\n", x);
  return 0;
}

输出如下：

6
6

如果外部变量很多，想按引用捕获外部所有变量的话，可以使用[&]方式，如下：

int main() {
  int x = 5;
  int y = 0;
  auto fun = [&]() { printf("%d, %d\n", ++x, --y); };
  fun();
  printf("%d, %d\n", x, y);
  return 0;
}

输出如下：

6 -1
6 -1

mutable关键字

本来mutable关键字应该单列一节来进行说明，但是因为其与捕获列表关系紧密，所以就暂时放在了本节一起来进行说明。

我们经常有一种需求，需要对某个变量进行修改，或者说局部范围内的修改，当退出该作用域的时候，变量又恢复原值。对于这种需求，我们可以尝试使用值捕获来完成，代码如下：

int main() {
  int x = 5;
  auto fun = [x]() { printf("%d\n", ++x); };
  fun();
  printf("%d\n", x);
  return 0;
}

编译之后，发现编译器会报错，如下：

错误：令只读变量‘x’自增
auto fun = [x]() { printf("%d\n", ++x); };

从上述编译器的输出来看，对于按值捕获的变量，编译器会将其设置为只读(read only)，所以对只读变量进行尝试修改的操作是不被编译器所允许的，而mutable 则可以解决此类错误，如下：

int main() {
  int x = 5;
  auto fun = [x]() mutable { printf("%d\n", ++x); };
  fun();
  printf("%d\n", x);
  return 0;
}

代码输出如下：

6
5

捕获全局变量和静态变量

一般情况下，lambda是用来捕获局部变量的，如果用其来捕获全局变量或者静态变量，那么编译器会报warning ，如下代码：

#include <iostream>
#include <vector>
#include <algorithm>

int x = 4;
int main() {
  auto fun = [x]() { printf("%d\n", x); };
  fun();

  return 0;
}

编译器输出如下：

test.cc: In function ‘int main()’:
test.cc:7:15: warning: capture of variable ‘x’ with non-automatic storage duration
    7 |   auto fun = [x]() { printf("%d\n", x); };
      |               ^
test.cc:5:5: note: ‘int x’ declared here
    5 | int x = 4;
      |     ^

捕获初始化表达式

自C++14开始，在捕获列表中可以使用初始化表达式，也就是说可以创建新的变量并在捕获子句中对其进行初始化。这种方式称之为带有初始化程序的捕获或者广义lambda捕获。

int main() {
  int x = 1;
  int y = 2;
  auto fun = [z = x + y]() { printf("%d\n", z); };
  fun();

  return 0;
}

在上面的例子中，编译器生成一个新的成员变量并用x+y对其进行初始化，也就是是说上面示例等价于:

int main() {
  int x = 1;
  int y = 2;
  int z = x + y;
  auto fun = [z]() { printf("%d\n", z); };
  fun();

  return 0;
}

混合捕获

混合捕获，还是比较好理解的，话不多说，直接上代码：

int main() {
  int x = 1;
  int y = 2;
  auto fun = [x, &y](){
    printf("%d, %d\n", x, ++y);
  };
  fun();
  
  return 0;
}

在上述代码中，对x进行按值捕获，而堆y则进行按引用捕获。

编译器实现

经常看我文章的读者，可能发现我的文章有个特点，喜欢说明白底层实现，其实这也是C++开发人员的一个特点，知其然，更要知其所有然，毕竟知己知彼，方能百战不殆嘛。

好了，言归正传，开始聊聊lambda的底层实现。那么我们该如何知道编译器的底层是如何实现的呢？在这里推荐一个工具cppinsights，是一款C++源代码到源代码的转换，它可以把C++中的模板、auto以及C++11新特性展开。通过使用cppinsights，我们可以清楚地看到编译器做了哪些事情。

值捕获

仍然使用前面的代码，如下：

int main() {
  int x = 5;
  auto fun = [x]() { printf("%d\n", x); };
  fun();
  return 0;
}

cppinsights输出如下：

int main()
{
  int x = 5;
    
  class __lambda_8_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      printf("%d\n", x);
    }
    
    private: 
    int x;
    
    public:
    __lambda_8_14(int & _x)
    : x{_x}
    {}
    
  };
  
  __lambda_8_14 fun = __lambda_8_14{x};
  fun.operator()();
  return 0;
}

从上面内容，我们可以看出，编译器针对lambda会生成一个类__lambda_8_14，然后调用该类的成员函数:

  • __lambda_8_14为由编译器针对lambda函数生成的一个类

  • __lambda_8_14定义了一个成员变量x，其初始值为

  • __lambda_8_14重载operator()其函数体为lambda函数体(本例中为printf("%d\n", x))

  • 源码中的fun在编译器实现之后，变成了一个__lambda_8_14对象

  • 对fun函数的调用，变成了调用__lambda_8_14对象的operator()函数

如果捕获列表内容为[=]，则类的private成员变量中会包含范围内的且在lambda中被使用的局部变量。假如有x和y两个变量，如果只使用了x这个变量，那么private成员变量就只有x，反之如果都使用了，则成员变量就变成了x和y。

如下代码：

int main() {
  int x = 5;
  int y = 6;
  auto fun = [=]() { printf("%d, %d\n", x, y); };
  fun();
  return 0;
}

上述代码的lambda部分，经过编译器编译之后，会变成如下：

class __lambda_9_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      printf("%d, %d\n", x, y);
    }
    
    private: 
    int x;
    int y;
    
    public:
    __lambda_9_14(int & _x, int & _y)
    : x{_x}
    , y{_y}
    {}
    
  };

在捕获列表中使用[=]，但是lambda实现体内只使用变量x，那么编译器又将如何操作呢？

int main() {
  int x = 5;
  int y = 6;
  auto fun = [=]() { printf("%d\n", x); };
  fun();
  return 0;
}

编译器对lambda部分的实现如下所示：

class __lambda_9_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      printf("%d\n", x);
    }
    
    private: 
    int x;
    
    public:
    __lambda_9_14(int & _x)
    : x{_x}
    {}
    
  };

上述输出中可见，对于[=]捕获方式，如果函数体内没有使用的变量，编译器不会生成对应的成员变量。

引用捕获

在上述值列表中，编译器会生成对应的成员变量，这样成员变量是对值列表中对应变量的一个拷贝，那么如果是引用列表，则成员变量则是对应变量的一个引用。

int main() {
  int x = 5;
  auto fun = [&x]() { printf("%d\n", ++x); };
  fun();
  printf("%d\n", x);
  return 0;
}

lambda部分经过编译器操作之后，如下：

class __lambda_8_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      printf("%d\n", ++x);
    }
    
    private: 
    int & x;
    
    public:
    __lambda_8_14(int & _x)
    : x{_x}
    {}
    
  };

可以看到，成员变量部分是引用列表中的引用，即int &x。

如果列表为[&]，则编译器将会生成对应变量的引用，规则与值列表类似，在此不再赘述。

C++中,const对成员变量的影响是:- const函数不能修改普通成员变量的值
- 但可以修改可变(mutable)成员变量
- 也可以修改引用类型的成员变量(因为引用本身是可以修改的)所以引用类型的n作为成员变量,不受const约束,可以在const operator()中被修改。这就是编译器특意设置的一个机制,来实现通过引用捕获访问外部变量的效果。

总结一下:

1. 引用捕获使外部变量成为lambda类的引用型成员
2. 引用类型成员不受const约束
3. 所以可以在const operator()中修改，所以引用捕获不用加mutable

mutable关键字

在前面内容中，可以看到，无论是按值捕获还是按引用捕获，编译器都会生成一个成员函数operator()，且被声明为const ，这也就意味着不能修改成员变量。

如果要修改此行为，则需要在参数列表后添加mutable关键字，这样就可以将const从operator()函数的声明中去除。

int main() {
  int x = 5;
  auto fun = [x]() mutable { printf("%d\n", ++x); };
  fun();
  return 0;
}

上述lambda在编译器中的实现如下：

 class __lambda_8_14
  {
    public: 
    inline /*constexpr */ void operator()()
    {
      printf("%d\n", ++x);
    }
    
    private: 
    int x;
    
    public:
    __lambda_8_14(int & _x)
    : x{_x}
    {}
    
  };

混合捕获

混合列表是值列表和引用列表的一种组合，了解了这两种实现，混合列表的编译器实现就更好理解了。

int main() {
  int x = 1;
  int y = 2;
  auto fun = [x, &y](){
    printf("%d, %d\n", x, ++y);
  };
  fun();
  
  return 0;
}

lambda部分编译器的底层实现如下：

class __lambda_9_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      printf("%d, %d\n", x, ++y);
    }
    
    private: 
    int x;
    int & y;
    
    public:
    __lambda_9_14(int & _x, int & _y)
    : x{_x}
    , y{_y}
    {}
    
  };

生成规则

看了前面的内容，lambda编译器的底层实现基本有了一个初步的认识，借助此文，将这个规则整理下:

编译器对lambda的生成规则如下：

  • lambda表达式中的捕获列表，对应lambda_xxxx类的private 成员

  • lambda表达式中的形参列表，对应lambda_xxxx类成员函数 operator()的形参列表

  • lambda表达式中的mutable，对应lambda_xxxx类成员函数 operator() 的常属性 const，即是否是常成员函数

  • lambda表达式中的返回类型，对应lambda_xxxx类成员函数 operator() 的返回类型

  • lambda表达式中的函数体，对应lambda_xxxx类成员函数 operator() 的函数体

效率

作为cpp开发人员，最关心的是性能问题。有些读者看完编译器对lambda的实现之后，感觉这么复杂的代码会不会效率很低？为了打消读者的疑虑，在本节中将从汇编角度进行分析。

我们以下面代码为例：

int main() {
  int x = 1;
  auto fun = [x](){
    printf("%d\n", x);
  };
  fun();
  
  return 0;
}

使用-std=c++17 -stdlib=libc++ -O3优化之后，汇编代码如下：

main: # @main
  push rax
  mov edi, offset .L.str
  mov esi, 1
  xor eax, eax
  call printf
  xor eax, eax
  pop rcx
  ret
.L.str:
  .asciz "%d\n"

从上述汇编代码可以看出，经过编译器优化之后，效率非常高，所以我们上面的担心完全是多余的。

揭开lambda的神秘面纱

Never-SayNever
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
项目小结--UUID
qq_41328653的博客
09-18 345
UUID的使用 UUID 是 通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的，是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。如此一来，每个人都可以创建不与其它人冲突的UUID。在这样的情况下，就不需考虑数据库创建时的名称重复问题。 UUIDUtils工具类： public class UUIDUtils { public static St
C++传递lambda表达式给函数
伊一易水寒的博客
07-18 5706
有时候，我们会需要将一个函数作为变元传递给另一个函数，这时，就需要了解函数指针的作用了 先来回顾一下函数指针： 函数指针不同于普通指针，它存储的内容还包括一个函数的返回类型和参数列表，形式为： 返回类型（ * 函数指针名 ） (参数列表），当一个函数指针创建后，它就只能指向对应返回类型和参数类型的函数，无法指向其他类型函数。 为了方便和正确起见，我们可以利用 auto 关键字让编译器自动识别函数类...
【C++11 之lambda表达式-语法+值传递、引用传递+应用场景】附匿名函数
最新发布
一起学习进步！
06-14 1551
capture-list：捕获列表，用于捕获外部作用域中的变量。parameter-list：参数列表，和普通函数的参数列表一样。return-type：返回类型，当函数体中的表达式类型可以明确推断出时，可以省略。function-body：函数体，包含函数实现的代码。
C++ Lambda函数 类中使用Lambda函数
qq_40669895的博客
11-24 2306
Lambda 是一种函数,lambda函数 表达式是一种匿名函数，即没有函数名的函数；该匿名函数是由数学中的λ演算而来的。这种函数可以定义在函数内部,所以Lambda函数里可以嵌套Lambda函数Lambda功能强大,外面的数据不想通过传到Lambda函数里的()里,可以传递到[]里,传到[]里会默认补上const 个人感觉是lambda这个函数可以写在函数里。 1.直接使用Lambda函数 auto Hello = []() { //Lambda 函数的样子 };//这里的分号别忘记了 #include
【C++进阶知识】03 - lambda表达式
qq_45617648的博客
07-25 287
对lambda表达式的知识进行详细剖析。
关于C++ 将lambda表达式作为参数传递
tankweight的博客
09-07 3674
https://blog.csdn.net/register_man/article/details/71330743 项目里面用到lambda，需要穿参数，看了这篇博文，便动手试了试。 先定义一个typedef void (^responsefunc)(Poco::Net::HTTPResponse::HTTPStatus result, const string&amp; response...
C++实现的lambda
01-13
本文将详细介绍LAMBDA方法以及如何使用C++实现这一算法。 LAMBDA方法是由Tijsseling在1996年提出的，主要用于双频GNSS观测数据的相位模糊度固定。它基于最小二乘原理，通过引入模糊度参数并考虑其统计特性，实现了...
rest-rpc 简单易用的rpc框架 C++11
10-22
- **C++11支持**：`rest_rpc`充分利用了C++11的新特性，如lambda表达式、智能指针、右值引用等，提高代码的可读性和效率。 - **简洁API**：框架提供简洁的API，使得开发者能够快速地定义服务和客户端。 - **异步/...
C++程序设计-原理-与-实践第2版—进阶篇.pdf
03-27
6. **C++11及更高版本的新特性**：除了基础内容，本书可能还会涵盖C++11、C++14和C++17引入的新特性，如lambda表达式、右值引用、自动类型推断（auto）和范围for循环等，这些都是提升代码质量和效率的重要工具。...
C++面试题目 以及 C++11 新语法.zip
01-20
6. **C++11新特性**：如lambda表达式、auto关键字、强类型枚举、右值引用、智能指针（unique_ptr、shared_ptr、weak_ptr）等，这些特性显著提升了C++的易用性和安全性。 7. **异常处理**：理解何时和如何使用try-...
Programming principles and practice Using C++ (C++程序设计原理与实践)
09-29
《C++程序设计原理与实践》是C++之父Bjarne Stroustrup撰写的一部经典著作，尤其在第二版中，它全面涵盖了C++11和C++14的新特性，是学习现代C++编程的必备参考资料。本书旨在帮助初学者理解编程的基本概念，并通过...
Effective Modern C++ Item 34 优先选用lambda式，而非std::bind
鳴海步的博客
12-24 372
1. 先来点历史资料 std::bind是C++98中std::bind1st和std::bind2nd的后继特性，但是作为一种非标准特性而言，std::bind在2005年就已经是标准库的组成部分了。正是在那时，标准委员会接受了名称TR1的文档，里面就包含了std::bind的规格（在TR1中，bind位于不同的名字空间，所以是std::tr1::bind而非std::bind，还有一些借口细节与现在有所不同）。 2. 再来谈抛弃 这样的历史意味着，有些开发者已经有了十多年的std::bind开发经验。如
C++11新特性：lambda表达式
程序人生
02-07 643
简介         lambda表达式（lambda expression）基于数学中的λ演算得名。在计算机科学中，我们可以将其理解为一个匿名内联函数，一个lambda表达式表示一个可调用的代码单元。        与任何函数类似，一个lambda具有一个返回类型、一个参数列表和一个函数体。但与函数不同，lambda可能定义在函数内部。C++的lambda表达式的基本语法如下：        ...
【C++11】lambda函数及其基本用法
bandaoyu的note
07-16 1741
lambda的语法比较简单，下面这个lambda返回一个字符串。 auto lambda = []{ return "hello world"; }; lambda(); //将返回 hello world 字符串 lambda还可以传参数。 auto lambda = [](std::string str){ return str; }; lambda("hello world"); //将返回 hello world 字符串 可以看到lambda就像一个函数一样，可以接受参......
lambda在C++中的运用(译stack overflow)
雾里看花
07-19 330
问题 c++中有类似std::for_each和std::transform的泛型函数(generic functions)使用起来非常方便.但仿函数运用在这种特殊的函数(即指上面的generic functions),却存在着问题,如下: #include &lt;algorithm&gt; #include &lt;vector&gt; namespace { struct f {...
C++11学习之——Lamda
qq_42479335的博客
05-02 532
c++11学习之——LambdaLambda的语法定义捕捉列表 写在前面的话： C++11标准已经出来很多年了，但是自己一直都没有去认真学习过，还是用着以前的标准，感觉是时候认真学习下这些东西，就当成是给自己的大脑上点油，重拾一下学习的信心。 Lambda的语法定义 [capture](parameters) mutable -> return-type(statement) 关于定义...
C++ lambda表达式的使用
qq_38600065的博客
06-26 252
C++ lambda表达式的使用 lambda语法如下： [函数对象参数](操作符重载函数参数) mutable 或 exception 声明 -> 返回值类型 {函数体} [函数对象参数] 函数对象是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些定义lambda表达式时，作用域内可见的局部变量。这部分不可省略。 [] 没有任何函数对象参数。 [=] 函数体可以使用可见的所有局部变量，按值传递。 [&] 函数体可以使用可见的所有局部变量，按引用传递。 [this] 函
C++11新特性-----lambada表达式（函数对象、闭包）
居老师的博客
05-09 389
作用： Lambda 表达式实际上就是提供了⼀个类似匿名函数的特性，⽽匿名函数则是在需要⼀个函数，但是⼜不想费⼒去命名⼀个函数的情况下去使⽤的。利⽤ lambda 表达式可以编写内嵌的匿名函数，⽤以替换独⽴函数或者函数对象，并且使代码更可读。 这里简单介绍一下函数对象： 一个函数对象，即一个重载了括号操作符“（）”的对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子： class myprint { public: voi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值