>
Home

登龙（DLonng）

选择大于努力

C++11 - Lambda 表达式用法

版权声明：本文为 DLonng 原创文章，可以随意转载，但必须在明确位置注明出处！

什么是 Lambda 表达式？

Lambda 表达式是 C++11 提出的新特性，主要用来实现代码中函数的内嵌，简化了编程，提高了效率。

它的基本格式如下：

auto fun = [捕获参数](函数参数){函数体};

例如这个 Hello Lambda：

auto fun = [](){ std::cout << "Hello Lambda" << std::endl; };

Lambda 本质上是一个内联函数，只是定义和使用的方式与普通的函数有些不同，下面来具体介绍下它的基本语法。

基本语法

口说无凭，这里基于实际例子来介绍。

最简单的 Lambda

后面不加 () 的 Lambda 表达式相当于函数指针，加上 () 就相当于调用这个 Lambda 函数。

int main(void) {
  // Function point
  [](){ cout << "Hello World!" << endl; };
  // Call function
  [](){ cout << "Hello World!" << endl; }();
  return 0;
}

Lambda 可以赋值

可以将 Lambda 表达式赋值给一个变量，之后这个变量可以当作函数指针来调用，需要加上 ()。

int main(void) {
  auto fun = [](){ cout << "Hello World!" << endl; };
  fun();
  return 0;
}

为 Lambda 传递参数

可以为 Lambda 指定函数参数，该参数也具有副本机制。

int main(void) {
  int num = 100; 	
  // 为 Lambda 定义一个 int 类型的参数
  auto fun = [](int num){ num = 5; cout << num << endl; };
  fun(num);
  // num = 100
  cout << num << endl;
  return 0;
}

获取 Lambda 的返回值

Lambda 的返回值类型可以进行类型转换或者使用 decltype 自动推导。

int main(void) {
  // 1. 返回 `a + b` 的类型
  int num1 = [](int a, int b){ return a + b; }(1, 2);
  // 2. 返回值转换成 int 类型
  int num2 = [](double a, double b)->int{ return a + b; }(1.2, 2.1);
  // 3. 自动推导返回值的类型
  double num3 = [](double a, double b)->decltype(a + b){ return a + b; }(1.2, 2.1);
  cout << num1 << endl;
  cout << num2 << endl;
  cout << num3 << endl;
  return 0;
}

[ ] 的使用方法

Lambda 表达式的 [] 用来确定捕获参数：

  1. [=]：捕获的局部变量只可读不可写，捕获范围是当前 Lambda 表达式之前的作用域。
  2. [&]：捕获的局部变量可读可写。
int main(void) {
  int num = 100;
  // read only 
  auto fun1 = [=](){ cout << num << endl; };
  fun1();

  // read and write
  auto fun2 = [&num](){ num = 200; cout << num << endl; };
  fun2();
  // num = 200
  cout << num << endl;
  return 0;
}

Lambda 是 const 函数

Lambda 默认是 const 函数，不能修改引用的变量，使用 mutable 可以取消该属性，但是 mutable 修改的只是副本。

int main(void) {
  int num = 100;

  // Lamnda is const function, use `mutable` can cancel const
  //auto fun = [=](){ num = 200; cout << num << endl; };
  auto fun = [=]() mutable { num = 200; cout << num << endl; };
  fun();
  // num = 100
  cout << num << endl;
  return 0;
}

Lambda 没有地址

Lambda 表达式是内联展开的，没有实际的地址，这是与普通函数的一个很大的区别。

int main(void)
{
  string str;
  auto fun = [](string str){cout << str << endl; }; 
  cin >> str;
  fun(str);
  //lambda表达式没有地址，是内联展开的
  //cout << (void*)fun << endl;
  return 0;
}

Lambda 在 class 中的使用

Lambda 在 C++ class 中的使用需要知道如何捕获 this。

void MyClass::function() {
  // 使用 [this] 来捕获 this
  auto fun1 = [this](int v){cout << v + this->num << endl; };
  // 使用 [&] 捕获所有父作用域的引用，包括 this
  auto fun2 = [&](int v){cout << v + this->num << endl; };
}

具体用法

遍历并修改 vector

这里列举一个使用 Lambda 的例子，其实在使用函数的地方都可以替换成 Lambda 表达式。

int main() {
  vector<int> vec = {1, 2, 3, 4, 5};
  // 定义 Lambda
  auto fun = [](int num){ cout << num << endl;}
  for_each(vec.begin(), vec.end(), fun);
  
  // 将 vec 中的元素都加 1，修改参数必须传递参数的引用
  for_each(vec.begin(), vec.end(), [](int& num){ num += 1;});
  for_each(vec.begin(), vec.end(), fun);
  return 0;
}

项目实例

在之前做过的一个项目中有如下的一段代码（具体的类替换了名字）：

void fun_call_back(const YourType& your_type) {
  you_function(your_type); 
}

g_bus.Attach(fun_call_back, "YourType");

这行代码的意思是某种条件达到，就会调用 fun_call_back 这个函数。

我们可以用 Lambda 简化这个调用，如下：

g_bus.Attach([this](const YourType& your_type){ you_function(your_type); }, "YourType");

为什么要用 [this] 呢？那是因为后面的 you_function 是成员函数，需要捕获 this 才可以调用这个函数。

Lambda 与仿函数

Lambda 与仿函数有些类似，仿函数是编译器实现 Lambda 的一种方式，编译器会将 Lambda 转换为一个仿函数对象，Lambda 可以视为仿函数的等价形式，编译器在发现 Lambda 函数出现语法错误的时候，会报出一些与构造函数相关的信息。

下面是一个仿函数例子，了解即可：

class TestLambda {
 public:
  TestLambda(float f) : x(f) {}
  // 仿函数，即一个类重载 () 运算符
  float operator()(float price) {
    return price * (1 - x / 100);
  }
 private:
  float x;
};

可以看到调用仿函数和 Lambda 是很类似的。

int main() {
  float f = 5.5f;
  TestLambda t(f);

  auto fun = [f](float price)->float{ return price * (1 - f / 100);};

  // 调用 TestLambda 的仿函数
  float p1 = t(3000);
  // 调用 Lambda 表达式
  float p2 = fun(3000);
  
  // 2835
  cout << p1 << endl;
  
  //2835
  cout << p2 << endl;
  return 0;
}

总结

Lambda 是 C++11 提出的新特性，简化了我们的代码，提高了编程的效率，应该了解并学会使用它。

DLonng at 06/05/17

‹ ›