C++11:Lambda表达式

lambda表达式是一个匿名类的成员函数

仿函数，又叫做函数对象，因为实现仿函数的方式就是重载一个类的operator()

Lambda表达式实际在底层实现的时候，编译器是完全按照函数对象的方式来处理的，如果我们定义了一个Lambda表达式，编译器会自动生成一个类，在该类中重载operator()

 

#include <iostream>
using namespace std;

int main()
{
  []
  {
    cout << "hello lambda" << endl;
  }();    

  return 0;
}

int main()
{
　　auto l = []
   {
　　  cout << "hello lambda" << endl;
   };
   l();
   return 0;
}

 

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

using namepsace std;

int main()
{
  int a = 10, b = 100;
  auto Add = [](int x, int y)->int {
    return x + y;
  };
  cout << Add(a, b) << end;
  return 0;    
}

 

传值方式捕捉变量

int main()
{
  int a = 10, b = 20;
  //传值捕捉
  auto Func1 = [a, b]{
    return a + b;
  };
  cout << Func1() << endl;
  return 0;
}

 

传引用方式捕捉变量

int main()
{
  int a = 10, b =20;
  //传引用捕捉
  auto Func2 = [&a, &b] {
    int tmp = a;
    a = b;
    b = tmp;
  };
  Func2();
  cout << a << "-" << b << endl;
  return 0;
}

 

传值方式捕捉父作用域中的所有变量 (包括this) :

int main()
{
  int a = 10, b = 20, c = 1, d = 2, e = 3;
  //传值方式捕捉父作用域中的所有变量（包括this）  
  auto Func3 = [=] {
    return a + b + c + d + e;
  };
  cout << Func3() << endl;
  return 0;
}

 

传引用方式捕捉父作用域中的所有变量（包括this）:

int main()
{
  int a = 10, b = 20, c = 1, d = 2, e = 3;
  //传引用方式捕捉父作用域中的所有变量（包括this）
  auto Func4 = [&] {
    a = a + b + c + d + e;
  };  
  Func3();
  cout << a << endl;
  return 0;
}

 

混合捕捉：

 

int main()
{
  int a = 10, b =20, ret = 0;
  // 混合方式
  auto Func5 = [a, b, &ret]{
    ret = a + b;
  };
  Func5();
  cout << ret << endl;
  
  //ret 传引用捕捉，其他全部传值捕捉
  auto Func6 = [=. &ret]{
    ret = a + b;
  };
  Func6();
  cout << ret << endl;
  return 0;

}

 

 

 

Lambda表达式为了一些简单的函数直接调用封装
[var]:表示值传递方式捕捉变量var
[=]:表示值传递捕捉所有父作用域中的变量（包括成员函数中的this）
[&var]:表示引用传递捕捉变量var
[&]:表示引用传递捕捉所有父作用域中的变量（包括成员函数中的this）
[this]:表示值传递方式捕捉当前的this指针

 

//实现add的lambda
auto add = [](int a, int b)->int {return a + b; };
std::cout << add(1, 2) << std::endl;

//实现swap的lambda
auto swap1 = [](int& a, int& b)
{
int temp = a;
a = b;
b = temp;
};

int a = 10, b = 20;
auto swap2 = [&a, &b]
{
int temp = a;
a = b;
b = temp;
};

 

//函数对象
class AddUtil
{
  public:
    AddUtil(int a = 0, int b = 0)
      : _a(a), _b(b)
    {
    }

    int operator()()
    {
      return _a + _b;
    }

private:
    int _a;
    int _b;

};

int main()
{
  AddUtil A(10, 20);
  cout << A() << endl;
  return 0;
}