(C++) 从stl算法的谓词 分析lambda表达式的本质

已于 2023-02-01 19:55:05 修改
阅读量738 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言 源码软件
于 2023-01-16 22:50:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUBE_lotus/article/details/128710201
版权
文章详细介绍了C++11引入的lambda表达式的概念，以及它如何替代之前的函数指针和仿函数方法。通过std::sort函数的例子，展示了lambda如何直接使用、用auto接收、函数指针接收以及std::function接收的方式，并分析了其内部工作原理。此外，还提及了C++14和C++17/20对lambda表达式的增强，如C++14中的模板参数和C++17以后的this捕获优化。
摘要由CSDN通过智能技术生成

文章目录

前言

lambda表达式是C++11增加的一个新特性，深受各位开发者的喜爱。

而探究lambda表达式的本质是什么，就是本文的主要内容。

辅助工具

源码探查工具：C++ Insights (cppinsights.io)

这个网站可以根据源码生成中间代码，辅助学习者学习C++的中间过程。这个网站是基于clang实现的。

本文未做特殊说明，默认以C++11标准为例

基本代码

这里就用std::sort()的第三个参数，这里需要的谓词来进行分析。

#include <algorithm>
#define M 10

int main() {
    int arr[M];

    std::sort(arr, arr + M);

    return 0;
}

原始方法

先来看看在C++11之前是怎么实现的

函数指针法

Source:

#include <algorithm>
#define M 10

bool cmp(const int &x, const int &y) {
    return x < y;
}

int main() {
    int arr[M];

    std::sort(arr, arr + M, cmp);

    return 0;
}

Insight:

#include <algorithm>
#define M 10

bool cmp(const int & x, const int & y)
{
  return x < y;
}


int main()
{
  int arr[10];
  std::sort(arr, arr + 10, cmp);
  return 0;
}

仿函数法

Source:

#include <algorithm>
#define M 10

class Cmp {
public:
    bool operator()(const int &x, const int &y) {
        return x < y;
    }
};

int main() {
    int arr[M];

    std::sort(arr, arr + M, Cmp());

    return 0;
}

Insight:

#include <algorithm>
#define M 10

class Cmp
{
  
  public: 
  inline bool operator()(const int & x, const int & y)
  {
    return x < y;
  }
  
  // inline constexpr Cmp(const Cmp &) noexcept = default;
  // inline constexpr Cmp(Cmp &&) noexcept = default;
};



int main()
{
  int arr[10];
  std::sort(arr, arr + 10, Cmp(Cmp()));
  return 0;
}

分析总结

可见在C++11之前，无论是函数指针，还是仿函数，都是比较原始的实现谓词的方式

lambda表达式

直接写在谓词处

开门见山，lambda表达式就是一个具有仿函数的匿名类

展开的代码直接放到本地编译器，也是可以正常编译运行的

由上面的原始方法可知，去掉inline operator retType_7_29 () const noexcept{}和static inline bool __invoke(const int & x, const int & y){}可是没问题的

Source:

#include <algorithm>
#define M 10

int main() {
    int arr[M];

    std::sort(arr, arr + M, [](const int &x, const int &y) { return x < y; });

    return 0;
}

Insight:

#include <algorithm>
#define M 10

int main()
{
  int arr[10];
    
  class __lambda_7_29
  {
    public: 
    inline bool operator()(const int & x, const int & y) const
    {
      return x < y;
    }
    
    using retType_7_29 = bool (*)(const int &, const int &);
    inline operator retType_7_29 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline bool __invoke(const int & x, const int & y)
    {
      return __lambda_7_29{}.operator()(x, y);
    }
    
    public: 
    // inline /*constexpr */ __lambda_7_29(const __lambda_7_29 &) noexcept = default;
    // inline /*constexpr */ __lambda_7_29(__lambda_7_29 &&) noexcept = default;
    // inline __lambda_7_29 & operator=(const __lambda_7_29 &) /* noexcept */ = delete;
    
  };
  
  std::sort(arr, arr + 10, __lambda_7_29(__lambda_7_29{}));
  return 0;
}

下面，我们看看不直接写在谓词处，而是用变量接收lambda表达式是怎么样的

auto接收lambda表达式

可见auto识别成了这个匿名对象的类型。

Source:

#include <algorithm>
#define M 10

int main() {
    int arr[M];

    std::sort(arr, arr + M, [](const int &x, const int &y) { return x < y; });

    return 0;
}

Insight:

#include <algorithm>
#define M 10

int main()
{
  int arr[10];
    
  class __lambda_7_16
  {
    public: 
    inline bool operator()(const int & x, const int & y) const
    {
      return x < y;
    }
    
    using retType_7_16 = bool (*)(const int &, const int &);
    inline operator retType_7_16 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline bool __invoke(const int & x, const int & y)
    {
      return __lambda_7_16{}.operator()(x, y);
    }
    
    public: 
    // inline /*constexpr */ __lambda_7_16(const __lambda_7_16 &) noexcept = default;
    // inline /*constexpr */ __lambda_7_16(__lambda_7_16 &&) noexcept = default;
    // inline __lambda_7_16 & operator=(const __lambda_7_16 &) /* noexcept */ = delete;
    
  };
  
  __lambda_7_16 cmp = __lambda_7_16(__lambda_7_16{});
  std::sort(arr, arr + 10, __lambda_7_16(cmp));
  return 0;
}

而在本地的vscode中，auto和cmp的自动识别却不一样

auto cmp = [](const int &x, const int &y) { return x < y; };

// auto 的自动识别
class lambda [](const int &x, const int &y)->bool
// cmp 的自动识别
bool cmp(const int &x, const int &y)

函数指针接收lambda表达式

当左值的类型确定后，等号右侧若不是完全匹配的配型，一般需要强转

这里很明显的用static_cast<bool (*)(const int &, const int &)>进行了强转

而强转的内容是__lambda_6_45{}.operator __lambda_6_45::retType_6_45()查看源码可见实质是把__invoke这个函数指针传出去了，而__invoke的内容就是调用了仿函数，这是比较常见的一种类的内部保护机制

注意这里是把仿函数的，函数类型指针做了一个符号重载

using retType_6_45 = bool (*)(const int &, const int &);

inline operator retType_6_45 () const noexcept {}

Source:

#include <algorithm>
#define M 10

int main() {
    int arr[M];
    bool (*cmp)(const int &, const int &) = [](const int &x, const int &y) {
        return x < y;
    };
    std::sort(arr, arr + M, cmp);

    return 0;
}

Insight:

#include <algorithm>
#define M 10

int main()
{
  int arr[10];
      
  class __lambda_6_45
  {
    public: 
    inline bool operator()(const int & x, const int & y) const
    {
      return x < y;
    }
    
    using retType_6_45 = bool (*)(const int &, const int &);
    inline operator retType_6_45 () const noexcept
    {
      return __invoke;
    }
    
    private: 
    static inline bool __invoke(const int & x, const int & y)
    {
      return __lambda_6_45{}.operator()(x, y);
    }
    
    
  };
  
  using FuncPtr_6 = bool (*)(const int &, const int &);
  FuncPtr_6 cmp = static_cast<bool (*)(const int &, const int &)>(__lambda_6_45{}.operator __lambda_6_45::retType_6_45());
  std::sort(arr, arr + 10, cmp);
  return 0;
}

std::function接收lambda表达式

函数指针一直是一个比较头痛的内容。在C++11推出了std::function大大改善了接收函数指针的方式

所在头文件：#include <functional>

看的出来，这就是一个再封装一层的对象而已，将lambda的匿名对象，强转成std::function对应的对象

Source:

#include <algorithm>
#define M 10

int main() {
    int arr[M];
    bool (*cmp)(const int &, const int &) = [](const int &x, const int &y) {
        return x < y;
    };
    std::sort(arr, arr + M, cmp);

    return 0;
}

Insight:

#include <algorithm>
#include <functional>
#define M 10

int main()
{
  int arr[10];
    
  class __lambda_7_41
  {
    public: 
    inline bool operator()(const int & x, const int & y) const
    {
      return x < y;
    }
    
    using retType_7_41 = bool (*)(const int &, const int &);
    inline operator retType_7_41 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline bool __invoke(const int & x, const int & y)
    {
      return __lambda_7_41{}.operator()(x, y);
    }
    
    public: 
    // inline /*constexpr */ __lambda_7_41(const __lambda_7_41 &) noexcept = default;
    // inline /*constexpr */ __lambda_7_41(__lambda_7_41 &&) noexcept = default;
    
  };
  
  std::function<bool (int, int)> cmp = std::function<bool (int, int)>(std::function<bool (int, int)>(__lambda_7_41(__lambda_7_41{})));
  std::sort(arr, arr + 10, std::function<bool (int, int)>(cmp));
  return 0;
}

分析总结

用最简单的一句话总结就是，lambda表达式是一个具有仿函数的匿名类

而编译器就是想尽各种办法去调用到这个仿函数

C++11之后的lambda表达式

在C++11之后，C++14,17,20都不断的对lambda表达式进行了优化和增强

下面用C++14的增强举个小例子

C++14增强的例子

在C++14中，可以用auto作为参数实现类似泛型的操作

而查看展开后的源码发现，其实就是对仿函数改为了模板编程

每次不用参数的调用，都会展开一份特化的代码

Source:

int main() {
    int num = 10;
    auto fun = [var = num](auto x) mutable { return x; };

    fun(1);
    fun('a');

    return 0;
}

Insight:

int main()
{
  int num = 10;
    
  class __lambda_3_16
  {
    public: 
    template<class type_parameter_0_0>
    inline auto operator()(type_parameter_0_0 x)
    {
      return x;
    }
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline int operator()<int>(int x)
    {
      return x;
    }
    #endif
    
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline char operator()<char>(char x)
    {
      return x;
    }
    #endif
    
    private: 
    int var;
    public: 
    // inline /*constexpr */ __lambda_3_16(__lambda_3_16 &&) noexcept = default;
    __lambda_3_16(int & _var)
    : var{_var}
    {}
    
  };
  
  __lambda_3_16 fun = __lambda_3_16(__lambda_3_16{num});
  fun.operator()(1);
  fun.operator()('a');
  return 0;
}

C++17,20的增强

C++17,20主要是对this捕获的增强，无状态的构造和复制等等。这里就不再展开例子了。

END

天赐细莲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++中使用lambda表达式的作用和用法
usstmiracle的博客
02-27 1104
lambda表达式的使用场景有很多，作为小型函数对象，例如在需要一个简单的函数对象时，可以使用lambda表达式来定义一个匿名的函数对象，而不需要定义一个单独的类或结构体。lambda表达式与普通函数类似，也有参数列表、返回值类型和函数体，只是它的定义方式更简洁，并且可以在函数内部定义。作为临时计算，例如在需要一个简单的计算结果时，可以使用lambda表达式来封装计算逻辑，而不需要定义一个单独的函数。作为回调函数，例如在STL的算法中，可以使用lambda表达式来自定义比较函数、谓词函数、操作函数等。
STL深度梳理之常用算法实现及lambda表达式（C++11/14)
实战开发者Airex
06-01 268
总第38篇 本文要主梳理STL中Lambda表达式的定制操作及常用的基本算法的实现方式。 1.Lambda表达式的定制 很多算法都会比较输入序列中的元素以达到排序的效果。通过定制比较的动作，就可以主算法按编程者的意图去工作 。这里我们以排序算法来说明。 普通的排序算法只能按照从小到大进行排序，很多时候并不适用。其普通排序算法...
C++ lambda 表达式深剖
qq_61500888的博客
10-16 2346
带你一命通关C++ lambda 表达式 十分钟手撕语法内涵
Lambda表达式的本质
zhc的博客
02-26 5230
lambda表达式又叫做匿名函数，lambda表达式本质是一个匿名类，下面咱们开始介绍下lambda表达式。
Java框架！深入底层原理—带你看透Lambda表达式的本质
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
08-05 597
===================================================================== 嗨咯，大家好，今天给带大家深入底层原理看透Lambda表达式的本质，如果本文对你有帮助，记得一键三连一下！！ 知识点 ====================================================================== Lambda的原理 Java 8支持动态语言，看到很酷的Lambda表达式，对一直以静态类型语言自居的Jav
深入底层原理—带你看透Lambda表达式的本质
weixin_57907028的博客
05-28 1815
前言 嗨咯，大家好，今天给带大家深入底层原理看透Lambda表达式的本质，如果本文对你有帮助，记得一键三连一下！！ 知识点 Lambda的原理 Java 8支持动态语言，看到很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。 Lambda的案例 import java.util.function.Consumer; public class Lambda { public static void main(String[] args) {
lambda表达式的核心目的，lambda配合流使用，本质是什么，口语化解释，简写的方式
星空的日常博客，希望日常能给你帮助
04-01 1761
lambda表达式的核心目的，本质是什么，口语化解释
C++语法系列——理解lambda表达式
Keep trying until you get it right
03-20 332
（1）什么是lambda表达式？ 形式上表现为匿名内联函数，具有参数列表、返回类型和函数体等组成部分，但又与普通函数有一定差别，即它还具有一个捕获列表，且可定义在函数内部。其形式如下： [ 捕获列表 ] （ 参数列表 ）-> 返回类型 { 函数体 } （2）捕获列表有何用处？ 其用处与lambda表达式的特性有关。由于lambda表达式可定义在函数内部，因此lambda表达式可...
有效使用Lambda表达式和std::function
01-31
C++11的lambda表达式使它们更有效地被使用函数对象类，即实现operator()的类，多年来被C++程序员所熟知，它们被用做 STL算法中的谓词(predicate)。然而，实现简单的函数对象类是一件繁琐的事情，如：假设v是int为...
STL之lambda表达式
weixin_34253539的博客
01-26 375
一、简介 我们可以向一个算法传递任何类别的可调用对象。对于一个对象或一个表达式，如果可以对其使用调用运算符，则称它为可调用的。即，如果e是一个可调用的表达式，则我们可以编写代码e（args），其中args是一个逗号分隔的一个或多个参数的列表。 可调用对象分别有：1、函数和函数指针；2、重载了函数调用运算符的类；3、lambda表达式。 一个lambda表达式表示一个可调用的代码单元。我们可以将其理...
C++中Lambda函数的含义及其本质
weixin_73233099的博客
02-07 7337
C++11新标准得Lambda函数！
【C++】lambda表达式
chuxinchangcun的博客
04-28 2137
写法2:利用捕捉列表进行捕捉变量以引用的方式捕捉所有父作用域中的变量,可以省略参数列表和返回值类型。
C++ lambda表达式及其原理
08-05 292
概述 C++ 11中引入了新的lamdba表达式，使用也很简单，我最喜欢的是不用给函数取名称，每次给函数取名称都感觉自己读书太少~ 1、lambda表达式 lambda表达式可以理解为一个匿名的内联函数。和函数一样，lambda表达式具有一个返回类型、一个参数列表和一个函数体。与函数不一样的...
Lambda 表达式
weixin_51313154的博客
07-23 2066
lambda表达式的本质是接口的实例对象。
C++中lambda表达式详解与原理分析
LPWSTR的博客
03-20 8227
lambda表达式的本质就是重载了()运算符的类，这种类通常被称为functor，即行为像函数的类。因此lambda表达式对象其实就是一个匿名的functor。 C++中lambda表达式的构成 一个标准的lambda表达式包括：捕获列表、参数列表、mutable指示符、尾置返回类型（-&gt;返回类型）和函数体： [capture list] (params list) mutab...
Lambda表达式深入解析
中国华的博客
11-18 279
1.Lambda介绍 lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块) 匿名的，有输入输出，但没有函数名 Function 简洁的 2.Lambda表达式的语法 2.1 基本语法 (parameters) -> expression 或 (parameters) ->{ statements;} 2.2 简单例子 //1.接受参数，并有返回值 Comparator
【C++】 Lambda表达式详解
最新发布
kinghzking的专栏
06-09 3276
仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符，仿函数与Lamdba表达式的作用是一致的。如果Lambda表达式的函数体只有一条语句，且该语句的返回值类型可以自动推导，则可以省略返回值类型和return关键字。记得去年立了一个重学C++新特性的flag，可是真的太忙了，大部分精力都花在全栈上了，今年开始看一些开源源码，发现各种奇怪的语法，根本看不懂，，它可以方便地定义一个匿名函数，从而简化代码的编写。，可以像函数一样被调用，也可以作为函数参数或返回值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值