C++11 新特性 ⑤ | 仿函数与 lambda 表达式

ゝ一纸荒年。 2024-04-17 11:18 76阅读 0赞

**目录**

1、引言

2、仿函数

3、lambda表达式

3.1、lambda表达式的一般形式

3.2、返回类型说明

3.3、捕获列表的规则

3.4、可以捕获哪些变量

3.5、lambda表达式给编程带来的便利

--------------------

[VC++常用功能开发汇总（专栏文章列表，欢迎订阅，持续更新...）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/article/details/124272585][VC_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_124272585][C++软件异常排查从入门到精通系列教程（专栏文章列表，欢迎订阅，持续更新...）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/article/details/125529931][C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_125529931][C++软件分析工具从入门到精通案例集锦（专栏文章正在更新中...）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/article/details/131405795][C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_131405795][C/C++基础与进阶（专栏文章，持续更新中...）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/category\_11931267.html][C_C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_category_11931267.html] C++11新特性很重要，作为C++开发人员很有必要去学习，不仅笔试面试时会涉及到，开源代码中也在大规模的使用。以很多视频会议及直播软件都在使用的开源WebRTC项目为例，WebRTC代码中大篇幅地使用了C++11及以上的新特性，要读懂其源码，必须要了解这些C++的新特性。所以，接下来一段时间我将结合工作实践，给大家详细讲解一下C++11的新特性，以供借鉴或参考。

### 1、引言 ###

![e5c5f3825b8d437f9091480d56d4afde.png][]

在C++中我们可以使用函数名、函数指针、仿函数去实现函数的调用。C++11引入了lambda表达式，又称匿名函数，给我们引入了一种新的函数调用方式，给我们编程带来了很大的便利。今天我们来讲讲仿函数和lambda表达式。

### 2、仿函数 ###

仿函数是一种特殊的类或结构体，不是C++11引入的，之前就有了。它重载了函数调用运算符operator()，并且可以像函数一样被调用，同时它也可以拥有自己的数据成员和成员函数。仿函数通常用于算法（如sort、find、transform等）和容器（如set、map、list等）中，以提供自定义的操作行为。在C++11中，可以使用lambda表达式实现简单的仿函数。

下面是个类中重载 operator()的实例：

class MyFunctor
    {
    public:
        MyFunctor(int tmp) : round(tmp) {}
        int operator()(int tmp) { return tmp + round; }
    private:
        int round;
    };
    
    int main()
    {
        int round = 2;
        MyFunctor f(round); //调用构造函数
        cout << "result = " << f(1) << endl; // operator()(int tmp)
    
        return 0;
    }

通过类对象去调用重载的operator()方法。 在C++里，我们通过在一个类中重载operator()运算符的方法，去使用一个函数对象而不是一个普通函数。

再看一个比较数大小的实例：

class compare_class
    {
        public:
        bool operator() (int A, int B) const{return A < B;}
    };
     
    // Declaration of C++ sorting function.
    template<class ComparisonFunctor>
    void sort_ints(int* begin_items, int num_items, ComparisonFunctor c);
     
    int main()
    {
        int items[]={4, 3, 1, 2};
        compare_class functor;
        sort_ints( items, sizeof(items)/sizeof(items[0]), functor);
    }

### 3、lambda表达式 ###

![2e6197ec280f49f498fc3c951437d3cc.png][]

lambda表达式，又称匿名函数，是一个可调用的代码单元，可以理解为一个未命名（匿名）的内联函数。与一般的函数类似，lambda表示式有一个返回类型、一个参数列表和一个函数体。但和函数不同的是，lambda表达式是直接定义在函数内部。

lambda表达式的引入，给我们编程带来了很大的便利，可以大大简化我们的编码！

#### 3.1、lambda表达式的一般形式 ####

lambda表达式的一般形式如下：

> **\[capture list\]( parameter list ) -> return type \{ function body \}**

其中：

> 1）capture list（捕获列表），是一个本表达式所在函数的局部变量的列表；  
> 2）parameter list（参数列表），是给本lambda表达式传入的参数列表；  
> 3）return type（返回类型），是本lambda表达式的返回值类型（可省略）；  
> 4）function body（函数体），是本lambda表达式的内部实现。

对于普通函数，返回类型位于函数开始处，但lambda表达式因为其形式，返回类型不能放在开始处，必须使用尾置的方式来指定返回类型。我们可以忽略参数列表和返回值类型，但必须包含捕获列表和函数体，比如：

auto f = [] { return 20; };

#### 3.2、返回类型说明 ####

直接在lambda表达式中指定返回类型，没什么问题。**下面我们看看没指定返回类型时，将会发生什么。**

**如果lambda表达式的函数体中只包含一个return语句**，如果没指定lambda表达式的返回值，则编译时会根据return语句中的内容推导出本表达式的返回值类型，比如实现两个整型数据相加的lambda表达式：

[] ( int a, int b) { return a + b; }

本lambda中没有指定函数返回类型，根据表达式（a+b）可以推断出本lambda返回值类型为int。

**如果lambda表示式中不是只包含单一的return语句（多条语句）**，编译时编译器认定该lambda返回值类型为void。比如返回一个数绝对值的lambda如下：

[] ( int a ) { if ( a < 0) return -a; else return a; };

**因为包含了多条语句，所以编译器认定该lambda返回void，编译时会报错！**因为返回类型为void，却使用return返回了int类型，不一致了，所以报错！

#### 3.3、捕获列表的规则 ####

捕获列表，涉及到访问所在函数哪些局部变量，以及访问变量的方式。访问变量的方式主要有以引用的方式访问，还是以值的方式访问。如果是将lambda要访问的变量在捕获列表中罗列出来，则是显示捕获；如果不罗列，就是隐式捕获。

下面给出完整的捕获列表规则：

<table> 
 <tbody> 
  <tr> 
   <td style="width:139px;"><strong>捕获类型</strong></td> 
   <td style="width:359px;"><strong>描述</strong></td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[]</td> 
   <td style="width:359px;">空捕获列表。lamda表达式内部不使用所在函数中的变量。只有捕获列表不为空才能使用所在函数中的变量。</td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[names]</td> 
   <td style="width:359px;">names是一个逗号分割的名字列表，这些名字是lamda所在函数的局部变量的名称。默认情况下，捕获列表中的变量值被拷贝，变量前面可以添加&amp;，加&amp;则表示采用引用捕获方式。</td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[&amp;]</td> 
   <td style="width:359px;">隐式捕获列表，让编译器根据lamda内部的代码去推断使用了所在函数的哪些局部变量。采用引用捕获方式，lamda体中所使用的来自所在函数的变量都采用引用方式使用。</td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[=]</td> 
   <td style="width:359px;">隐式捕获列表，让编译器根据lamda内部的代码去推断使用了所在函数的哪些局部变量。采用值捕获方式，lamda体中将拷贝所使用的来自所在函数的变量的值。</td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[&amp;, identifier_list]</td> 
   <td style="width:359px;"><strong>&nbsp;identifier_list（理解为不使用&amp;引用捕获的特例）</strong>是逗号分割的列表，包含0个或多个来自所在函数的变量，这些变量采用值捕获，<strong>identifier_list列表中的名字前面不能加&amp;</strong>。而除identifier_list列表中指明的变量之外的任何隐式捕获的变量都采用引用捕获方式。</td> 
  </tr> 
  <tr> 
   <td style="width:139px;">[=, identifier_list]</td> 
   <td style="width:359px;"><strong>identifier_listt（理解为不使用=值捕获的特例）</strong>是逗号分割的列表，包含0个或多个来自所在函数的变量，这些变量采用引用捕获，<strong>identifier_list列表中的名字前面必须使用&amp;</strong>。而除identifier_list列表中指明的变量之外任何隐式捕获的变量都采用值捕获方式。</td> 
  </tr> 
 </tbody> 
</table>

关于捕获列表的例子，如下：

int main()
    {
        int a = 0, b = 1;
        auto f1 = []{ return a; };      // error, 没有捕获外部变量
        auto f2 = [=]{ return a; };     // ok, 值传递方式捕获所有外部变量
        auto f3 = [=]{ return a++; };   // error, a是以赋值方式捕获的，无法修改
        auto f4 = [=]() mutable { return a++; };   // ok, 加上mutable修饰符后，可以修改按值传递进来的拷贝
        auto f5 = [&]{ return a++; };              // ok, 引用传递方式捕获所有外部变量, 并对a执行自加运算
        auto f6 = [a]{ return a+b; };              // error, 没有捕获变量b
        auto f9 = [a,&b]{ return a+(b++); };       // ok, 捕获a, &b
        auto f8 = [=,&b]{ return a+(b++); };       // ok, 捕获所有外部变量，&b
        auto f9 = [&,&b]{ return a+(b++); };       // error, 捕获所有外部变量，不能使用&b，b是特例，和默认的引用捕获不一样，使用值捕获，所以不能加&
        auto f10 = [=,b]{ return a+(b++); };       // error, 捕获所有外部变量，不能使用b，b是特例，和默认的值引用不一样，使用引用捕获，前面必须加&
        return 0;
    }

#### 3.4、可以捕获哪些变量 ####

一般lambda表达式是放置在一个函数中的，即在函数中嵌入的，lambda函数实现体中可以访问其所在函数的局部变量。**如果lambda表达式所在函数是一个类的成员函数，则lambda内部也可以访问当前函数所在的类的成员变量**，这一点可能很多人不知道。比如：

class Test
    {
    public:
        int i = 0;   // 类的成员变量
    
        void func(int x, int y)
        {
            auto x1 = []{ return i; };          // error, 没有捕获外部变量
            auto x2 = [=]{ return i+x+y; };     // ok, 值传递方式捕获所有外部变量
            auto x3 = [=]{ return i+x+y; };     // ok, 引用传递方式捕获所有外部变量
            auto x4 = [this]{ return i; };      // ok, 捕获this指针
            auto x5 = [this]{ return i+x+y; };  // error, 没有捕获x, y
            auto x6 = [this, x, y]{ return i+x+y; };// ok, 捕获this指针, x, y
            auto x9 = [this]{ return i++; };        // ok, 捕获this指针, 并修改成员的值
        }
    };

#### 3.5、lambda表达式给编程带来的便利 ####

lambda表达式的引入，给我们编程带来了很大的便利，可以大大简化我的编码。比如我们在使用STL容器的find\_if、count\_if、sort等算法函数时，我们要传入条件函数或者比较函数，这些函数直接用lambda表达式去实现，要方便很多。  
在以前没有lambda表达式时，这些条件函数和比较函数，需要在函数外实现，要不定义成全局函数，要不定义成静态函数，甚至还要定义一些辅助的全部或者静态变量。比如有一个存放设备信息的结构体，然后有个存放设备信息的vector列表，给该列表简单的初始化一下：

// 设备信息结构体
    typedef struct tagDeviceInfo
    {
        char szDeviceId[64];   // 设备id
        char szDeviceName[64]; // 设备名称
        int nDevType;          // 设备类型
    
    public:
        tagDeviceInfo(){ memset(this, 0, sizeof(tagDeviceInfo)); }
    }TDeviceInfo;
    
    // 设备管理类
    class CDeviceManage
    {
        CDeviceManage();
        ~CDeviceManage();
    
        void InitDeviceList();
    
    private:
        vector<TDeviceInfo> m_vtDevList;
    }
    
    // 初始化设备列表（仅用于测试，随意初始化了一些数据）
    void CDeviceManage::InitDeviceList()
    {
        for ( int i = 0; i < 10; i++ )
        {
            TDeviceInfo tDevInfo;
    
            char szBuf[128] = { 0 };
            sprintf(szBuf, "E40CF3E4-CC2B-437F-A4B9-65F2D5BD071%d", i);
                                       strcpy(tDevInfo.szDeviceId, szBuf);
    
            CUIString strName;
            sprintf(szBuf, "设备%d", i);
                                       strcpy(tDevInfo.szDeviceName, szBuf);
    
            m_vtDevList;.push_back(tDevInfo);
        }
    }

假设我们在CDeviceManage::FindTest成员函数中**调用STL的算法函数find\_if到m\_vtDevList列表中搜索设备Guid**（szDeviceId）为E40CF3E4-CC2B-437F-A4B9-65F2D5BD0715的设备信息。如果不使用lambda表达式，则要将条件函数实现在CDeviceManage类外部定义成全局函数，同时要将存放目标id的变量定义成全局的，如下所示：

char* s_lpszTargetDevId = ""; // 定义成静态变量
    
    // 将条件匹配函数定义在类CDeviceManage外部，定义成全局函数
    BOOL MatchFunc(TDeviceInfo& tDevInfo)
    {
        return strcmp( s_lpszTargetDevId，tDevInfo.szDeviceId ) == 0;
    }
    
    bool CDeviceManage::FindTest()
    {
         // 对静态变量s_pTargetDevId进行赋值
         s_lpszTargetDevId = "E40CF3E4-CC2B-437F-A4B9-65F2D5BD0715";
         vector<TDeviceInfo>::iterator itor = std::find_if(m_vtDevList.begin(), m_vtDevList.end(), MatchFunc);
         if （ itor != m_vtDevList.end() ）
         {
             // 找到对应的设备信息，进行后续处理的代码省略
             // ......
    
             return true;
         }
    
         return false;
    }

上述代码实现的相对麻烦一些。  
如果使用lambda表达式，代码要简洁很多，**不用将条件匹配函数定义成全局函数，也不用定义静态辅助变量s\_lpszTargetDevId**，用lambda表达式实现的代码如下：

bool CDeviceManage::FindTest()
    {
        char* lpszTargetDevId = "E40CF3E4-CC2B-437F-A4B9-65F2D5BD0715";
        vector<TDeviceInfo>::iterator itor = std::find_if(vtDevList.begin(), vtDevList.end(), [=](const TDeviceInfo& tDevInfo){
        return strcmp(lpszTargetDevId, tDevInfo.achDeviceId) == 0; } );
    
        // 后续代码省略
        // ......
    }

至于为什么要使用STL的算法函数去搜索， 因为STL的算法函数的效率比较高，比直接去for循环遍历效率会高很多！如果STL列表中存放了大量的数据，数据搜索就要讲究效率了，就要使用到STL算法函数，比直接for循环变量要高上几个数量级，这点在项目中对比测试过！关于使用STL算法函数提高搜索效率的文章，可以参见我之前写的文章：

[VC++调用STL算法函数有效提升STL列表的搜索速度（附源码）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/article/details/123943134][VC_STL_STL_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_123943134][VC++如何使用C++ STL标准模板库中的算法函数（附源码）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/chenlycly/article/details/125486409][VC_C_ STL_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_125486409]

[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[VC_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_124272585]: https://blog.csdn.net/chenlycly/article/details/124272585
[C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_125529931]: https://blog.csdn.net/chenlycly/article/details/125529931
[C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_131405795]: https://blog.csdn.net/chenlycly/article/details/131405795
[C_C_..._icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_category_11931267.html]: https://blog.csdn.net/chenlycly/category_11931267.html
[e5c5f3825b8d437f9091480d56d4afde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/dec2b3d43b8043278afe3942dbf0242f.png
[2e6197ec280f49f498fc3c951437d3cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/b3c3e2cbc8934cdb9c628d53d2b220e9.png
[VC_STL_STL_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_123943134]: https://blog.csdn.net/chenlycly/article/details/123943134
[VC_C_ STL_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_chenlycly_article_details_125486409]: https://blog.csdn.net/chenlycly/article/details/125486409