C++11 Lambda表达式与匿名函数

lambda表达式是C++11中最重要的新特性之一，而Lambda表达式，实际上就是提供了一个类似匿名函数的特性，而匿名函数则是在需要一个函数，但是又不想费力去命名一个函数的情况下去使用的。这样的场景其实有很多很多，所以匿名函数几乎时现代编程语言的标配。

基础语法

Lambda表达式的基础语法如下：

返回值 = [捕获参数](传入参数列表)mutable(可选)异常属性 -> 返回类型{
    //函数体
}(传入参数并开始执行，无参数，则为空);//传入参数为空();


auto a = [捕获参数](传入参数列表)mutable(可选)异常属性 -> 返回类型{
    //函数体
}(传入参数并开始执行，无参数，则为空);//传入参数为空();
a(传入参数);//调用
  • Lambda表达式以一对中括号开始
  • 有参数列表
  • 有函数体，会有return语句
  • 一般不需要说明返回值类型(auto)，有特殊情况需要说明时，应使用箭头语法的方式
  • 每个lambda表达式都有一个全局唯一的类型，要精确捕捉lambda表达式到一个变量中，只能通过auto声明的方式
#include <iostream>
using namespace std;

int main()
{
   int c =  [](int a, int b) ->int {
        return a+b;
  }(1, 2);
  cout << c << endl;
    system("pause");
    return 0;
}

结果等于3

函数保存

auto f =  [](int a, int b) -> int {return a+b;}
auto c = f(1,2);

捕获列表与mutable

  • 对参数只读
#include <iostream>
using namespace std;

int main()
{
    int i = 10;
   int c =  [i](int a, int b) ->int {
        return a+b+i;
  }(1, 2);
  cout << c << endl;
    system("pause");
    return 0;
}
  • 对参数读写
#include <iostream>
using namespace std;

int main()
{
    int i = 10;
   int c =  [i](int a, int b) ->int {
       i++;
        return a+b+i;
  }(1, 2);
  cout << c << endl;
    system("pause");
    return 0;
}
error: increment of read-only variable 'i'
  • 加mutable
  • mutable实际上对原参数在子函数中的一种复制(按值传递)成为一个局部变量。未改变源参数的值
#include <iostream>
using namespace std;

int main()
{
    int i = 10;
   auto f =  [i](int a, int b)mutable ->int {
       i++;
       return a+b+i;
       };
  cout << "c = " << f(1,2) << endl;
  cout << "c = " << f(1,2) << endl;
  cout << "i = " << i << endl;
    system("pause");
    return 0;
}

结果如下

c = 14
c = 15
i = 10
  • 如果想修改原参数的值，可以通过引用捕获的方式
#include <iostream>
using namespace std;

int main()
{
    int i = 10;
   auto f =  [&i](int a, int b) ->int {
       i++;
       return a+b+i;
       };
  cout << "c = " << f(1,2) << endl;
  cout << "c = " << f(1,2) << endl;
  cout << "i = " << i << endl;
    system("pause");
    return 0;
}
c = 14
c = 15
i = 12
  • 捕获列表
auto f = [a, b](int c, int d) ->int{
    retrun a+b+c+d;
}
int h = f(1,2);
cout<<h<<endl;
  • 按值捕获所有参数
[=](int a, int b) ->int {
    return a+b;
}
  • 按引用捕获所有参数
[&](int a, int b) ->int {
    return a+b;
}
  • 混用
[a,b,&c,&d] ->int {
    ...
}
  • 类函数中使用-&可以引用传递类内所有数据，包括私有数据
#include <iostream>
#include <string>
class classA
{
private:
    int m_data;
public:
    classA(int data) :m_data(data){};
    int getm_data(){ return m_data; }
    void tryUseClassLambda(void);
};

void classA::tryUseClassLambda(void)
{
    [&] {
        m_data++;
        std::cout << "类内访问参数m_data：" << m_data << std::endl;
    }();//声明完立即调用
    return ;
}
int main()
{
    classA ca(1);
    ca.tryUseClassLambda();
    std::cout << "类外访问参数m_data：" << ca.getm_data() << std::endl;
    system("pause");
    return 0;
}
类内访问参数m_data：2
类外访问参数m_data：2
  • 在类中使用-this可以引用传递类内所有数据，包括私有数据
#include <iostream>
#include <string>
class classA
{
private:
    int m_data;
public:
    classA(int data) :m_data(data){};
    int getm_data(){ return m_data; }
    void tryUseClassLambda(void);
};

void classA::tryUseClassLambda(void)
{
    [this] {
        m_data++;
        std::cout << "类内访问参数m_data：" << m_data << std::endl;
    }();//声明完立即调用
    return ;
}
int main()
{
    classA ca(1);
    ca.tryUseClassLambda();
    std::cout << "类外访问参数m_data：" << ca.getm_data() << std::endl;
    system("pause");
    return 0;
}
类内访问参数m_data：2
类外访问参数m_data：2
© 允许规范转载