C++ 基础与深度分析 Chapter10 泛型算法（bind、lambada表达式、泛型算法的改进ranges）

已于 2022-06-29 09:35:17 修改
阅读量248 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2022-06-28 21:02:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43716712/article/details/125496000
版权

文章目录

概述

在这里插入图片描述
很多算法允许通过可调用对象自定义计算逻辑的细节

transform
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如何定义可调用对象：

  • 函数指针：概念直观，但定义位置受限
    在这里插入图片描述
    c++不支持在函数内部定义函数，所以位置是受限的。

  • 类：功能强大，但书写麻烦
    通过操作符重载，为类定义可调用对象。

  • bind ：基于已有的逻辑灵活适配，但描述复杂逻辑时语法可能会比较复杂难懂

  • lambda 表达式：小巧灵活，功能强大

bind

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
#include <iterator>
#include <functional>
using namespace std;

bool MyPredict2(int val1, int val2)
{
    return val1 > val2;
}
int main()
{
    using namespace std::placeholders;
    std::vector<int> x{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> y{};
    std::copy_if(x.begin(), x.end(), std::back_insert_iterator(y), std::bind(MyPredict2, _1, 3));
    for (auto p : y)
    {
        cout << p << ' '; // 4-10
        cout << endl;
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
#include <iterator>
#include <functional>
using namespace std;

bool MyPredict2(int val1, int val2)
{
    return val1 > val2;
}
int main()
{
    using namespace std::placeholders;
    auto x = std::bind(MyPredict2, _1, 3); // _1代表调用x时，接收x的第1个参数
    x(50); // 50会作为MyPredict2的第1个参数
    cout << x(50) << endl; // 1 true
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
#include <iterator>
#include <functional>
using namespace std;

bool MyPredict2(int val1, int val2)
{
    return val1 > val2;
}

bool MyAnd(bool val1, bool val2)
{
    return val1 && val2;
}
int main()
{
    using namespace std::placeholders;
    auto x1 = std::bind(MyPredict2, _1, 3); 
    auto x2 = std::bind(MyPredict2, 10, _1); 
    auto x3 = std::bind(MyAnd, x1, x2);
    cout << x3(5) << endl; // 1 意思为：3 < 5 < 10
}

调用 std::bind 时，传入的参数会被复制，这可能会产生一些调用风险
用智能指针解决
在这里插入图片描述
可以使用 std::ref 或 std::cref 避免复制的行为
在这里插入图片描述
bind还有一个缺点，就是复杂逻辑很难看懂代码。

std::bind_front （ C++20 引入）： std::bind 的简化形式
绑定第一个参数。
在这里插入图片描述
在这里插入图片描述

lambada表达式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
参数与函数体：

int main()
{
    auto x = [](int val) { return val > 3; }; // (函数形参) {函数体,多条语句，要用分号隔离}
    cout << x((5)) << endl; // 1, 5 > 3
}

int main()
{
    auto x = [](int val) { return (val > 3) && (val < 10); }; 
    cout << x((5)) << endl; // 1
}

在这里插入图片描述
返回类型的自动推导c++11。如果引入更多的return语句，所有的return语句的类型必须是相同的，这是前提。

int main()
{
    auto x = [](int val) 
    {
        if (val > 3)
        {
            return 3.0;
        }
        else
        {
            return 1.5;
        }
    
    }; 
    cout << x((5)) << endl; // 3,自动推导x的类型是double
}

int main()
{
    // 告诉编译器返回类型
    auto x = [](int val) -> float 
    {
        if (val > 3)
        {
            return 3.0;
        }
        else
        {
            return 1.5f;
        }
    
    }; 
    cout << x((5)) << endl; // 3
}

捕获： 针对函数体中使用的局部自动对象进行捕获

int main()
{
    int y = 10;

    auto x = [](int val)
    {
        return val > y; // 报错，在lambada表达式内部，不知道y是什么
    }; 
    cout << x((5)) << endl; 
}

int main()
{
    int y = 10; // 局部自动对象

    auto x = [y](int val)
    {
        return val > y; // 把y放到[]内进行捕获
    }; 
    cout << x((5)) << endl; 
}

int main()
{
    static int y = 10; // y是一个局部静态对象，不需要捕获，直接使用

    auto x = [](int val)
    {
        return val > y; 
    }; 
    cout << x((5)) << endl; 
}

值捕获

int main()
{
    int y = 10;

    auto x = [y] (int val) mutable
    {
        ++y;
        return val > y; 
    }; 
    cout << x((5)) << endl; 
    cout << y << endl; // 10 lambada对y的修改，不会传递到外部，因为是值捕获，y是复制到lambada内部
}

引用捕获

int main()
{
    int y = 10;

    auto x = [&y] (int val)
    {
        ++y;
        return val > y; 
    }; 
    cout << x((5)) << endl; 
    cout << y << endl; // 11 y是引用捕获
}

混合捕获

int main()
{
    int y = 10;
    int z = 3;

    // 对y进行引用捕获，对z进行值捕获 --> 混合捕获
    auto x = [&y, z] (int val) mutable 
    {
        ++y;
        return val > z; 
    }; 
    cout << x((5)) << endl; // 1
    cout << y << endl; // 11
}

如果lambada[捕获列表]里要捕获的值太多，这样就比价麻烦。大部分对象如果都是值捕获的，我们在[]里写个=。所有在{}使用的局部自动对象都值捕获了。我们也可以在[]中写入&，表示在{}使用的局部自动对象都引用捕获了。

int main()
{
    int y = 10;
    int z = 3;

    // []除了z是值捕获，其他都是引用捕获
    auto x = [&, z] (int val) mutable 
    {
        ++y;
        return val > z; 
    }; 
    cout << x((5)) << endl; 
    cout << y << endl; 
}

this 捕获

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
#include <iterator>
#include <functional>
using namespace std;

struct Str{
    auto fun()
    {
        int val = 3; // 局部自动对象
        // this 表示如果构造了Str对象，this就是一个指针，指向Str对象的地址
        auto lam = [val, this] ()  
        {
            return val > x;
        }; 
        return lam();
    }
    int x;
};

int main()
{
    Str s;
    s.fun();
}

初始化捕获（ C++14 ）

int main()
{
    int x = 3;
    // 初始化捕获，构造对象y，将x赋予y
    auto lam = [y = x](int val)
    {
        return val > y;
    };
    cout << lam(100) << endl;
}

在这里插入图片描述

int main()
{
    int x = 3;
    int y = 10;
    // z是在编译期计算出来的
    auto lam = [z = x + y](int val)
    {
        return val > z;
    };
    cout << lam(100) << endl;
}

*this 捕获（ C++17 ）
在这里插入图片描述
说明符
mutable

int main()
{
    int y = 3;
    auto lam = [y](int val) mutable
    {
        ++y; // 不能通过编译，除非加上mutable
        return val > y;
    };
}

constexpr (C++17)

int main()
{
    int y = 3;
    auto lam = [y](int val) constexpr
    {
        return val + 1; // 表示这个lam可以在编译期进行调用
    };
    constexpr int val = lam(100);
    cout << val << endl;
}

consteval (C++20)

int main()
{
    int y = 3;
    auto lam = [y](int val) consteval
    {
        return val + 1; // consteval只能在编译期调用
    };
    constexpr int val = lam(100);
    cout << val << endl;
}

lambada表达式的深入应用

在这里插入图片描述
捕获时计算

int main()
{
    int x = 3;
    int y = 5;
    // 捕获时计算
    auto lam = [z = x + y]()
    {
        return z;
    };
    lam();
}

即调用函数表达式（ Immediately-Invoked Function Expression, IIFE ）

int main()
{
    int x = 3;
    int y = 5;
    // 捕获时计算
    const auto val = [z = x + y]()
    {
        return z;
    }(); // 即调用函数表达式（ Immediately-Invoked Function Expression, IIFE ）
    // 构造完lam，构造完，马上执行lam 表达式
    // 执行完的值，马上赋给val，不需要额外定义函数
}

使用 auto 避免复制（ C++14 ）

int main()
{
    auto lam = [](auto x)
    {
        return x + 1;
    };
}

int main()
{
    std::map<int, int> m{{2, 3}};
    // 虽然用了引用，但是还是复制了
    auto lam = [](const std::pair<int, int>& p)
    {
        return p.first + p.second;
    };
    cout << lam(*m.begin()) << endl; // 5
}

int main()
{
    std::map<int, int> m{{2, 3}};
    auto lam = [](const auto& p)
    {
        return p.first + p.second;
    };
    cout << lam(*m.begin()) << endl; // 5
}

Lifting （ C++14 ）

#include <iostream>
#include <map>
using namespace std;

auto fun(int val)
{
    return val + 1;
}

auto fun(double val)
{
    return val + 1;
}

int main()
{
    // auto x，来决定用哪个fun
    auto lam = [](auto x)
    {
        return fun(x);
    };
    cout << lam(3) << endl; // 4
    cout << lam(3.5) << endl; // 4.5
    // auto b = std::bind(fun, 3); // bind不知道调用哪个fun了
    // cout << b() << endl;
}

递归调用（ C++14 ）

#include <iostream>
#include <map>
using namespace std;

/*
int factorial(int n)
{
    return n > 1 ? n * factorial(n - 1) : 1;
}*/

int main()
{
    // 这么写递归调用的lambada表达式会报错
    auto factorial = [](int n){
        return n > 1 ? n * factorial(n - 1) : 1;
    };
    cout << factorial(5) << endl; // 120
}

泛型算法的改进ranges

在这里插入图片描述

#include <iostream>
#include <algorithm>
#include <vector>
#include <ranges>
using namespace std;


int main()
{
    std::vector<int> x{1, 2, 3, 4, 5};
   //  auto it = std::ranges::find(x.begin(), x.end(), 3);
    auto it = std::ranges::find(x, 3);
    cout << *it << endl;
}

在这里插入图片描述
view并不是对输入的东西立即计算，而是需要的时候计算，把提升程序的性能。view模糊了容器和算法的概念了。

大叔爱学习.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++20新特性—range（一）
guxch的专栏
01-28 5434
“Ranges”的意思是一组元素的集合，既然是集合，最基本的操作就是对其中元素的枚举（iterate），按照一个集合是否可读写以及如何进行枚举，集合可分为以下几类（以concept形式体现）
C++泛型算法的一些总结
09-05
总之，C++的泛型算法提供了一套强大且灵活的工具，它们通过迭代器与各种容器进行交互，使得开发者能够专注于解决问题而不必关心底层数据结构的实现。在使用时，理解不同容器的特性和选择合适的算法版本至关重要，以...
C++20------Ranges
qq_38409301的博客
06-18 325
Ranges提供了其他功能。
笔记2-容器适配器/泛型算法/lambada表达式
J~的博客
11-30 212
容器适配器  容器适配器  stack quque priority_quque 接受一种已有的容器类型，使其行为看起来像另一种容器 stack及queue基于deque，priority_quque基于vector PS：介绍下value_type： 表示容器中的元素类型，该方法叫做type traits。见源代码 template vector { typedef T val
C++lambda表达式及bind函数总结
qq_39540537的博客
09-16 611
目录 引入lambda 值捕获 使用捕获列表 参数绑定 标准库bind函数 绑定check_size的sz参数 以下是对阅读<<C++Primer (第5版)>>lambda阅读部分总结 在实际的编程过程中,对于某些函数,我们希望对于传入的参数列表,其中某些参数是固定的值,而另外一个参数随着调用次数的增长而传入一个像STL容器一样的可迭代对象,对象的值随着*iterator值得不同而改变,每次调用该函数后会执行iterator++,并再次通过相同的传入参数调用该函数。
Ｃ++11 笔记 std::function，bind绑定器和lambda
花花邪思的博客
11-06 3850
Ｃ++11 笔记 std::function，bind绑定器和lambda背景c++将boost库中的function和bind在c++11中终于纳入了标准库的体系。 在传统的c++程序中，事件回调是通过虚函数进行的。在现代c++程序中，事件回调有了新的推荐做法，即std::funciton+std::bind,这种方式的一个明显优势是不必担心对象的生存期。 function模板类和bind模板函
C++算法与泛型算法（algorithm、numeric）
08-25
C++算法与泛型算法 C++算法与泛型算法是一种强大的工具，用于操作容器中的元素。这些算法可以分为三类：只读算法、写算法和重排元素算法。下面将对这些算法进行详细的介绍。 一、算法简介 大多数算法在头文件`...
算法岗位之c++部分面试准备6面向对象与泛型编程
01-08
右值引用(&&)是C++11中引入的新特性 , 它实现了转移语义和精确传递。它的主要目的有两个方面： 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。 能够更简洁明确地定义泛型函数。 左值和右值的...
java8 默认带的lambda 泛型函数式接口总结
qq_25497867的博客
12-26 3552
Predicate    T -> boolean Consumer     T -> void Function   T -> R Supplier    () -> T UnaryOperator  T -> T BinaryOperator   (T,T) -> T BiPredicate  (L,R) ->boolean BiConsumer  (T,U) -> void
lambda和bind详解
ahelloyou的博客
08-05 1078
精华： 什么是可调用对象 就是可以对它使用调用运算符（）的对象或者表达式 在c++ 中有以下几种可调用的对象 （1）函数 （2）函数指针 （*fun）(); （3）lambda表达式 （4）bind 创建的对象 （5）重载了函数调用符的类 什么是lambda 转载 简单来说，Lambda是一个可调用的代码单元。可以理解为一个未命名的内联函数；它的语法定义如下： [capture](parameters) mutable ->return-type{statement} 可以忽略参数列表和返回类型
java8中lambda表达式的应用，以及一些泛型相关
weixin_30641465的博客
01-03 981
语法部分就不写了，我们直接抛出一个实际问题，看看java8的这些新特性究竟能给我们带来哪些便利 顺带用到一些泛型编程，一切都是为了简化代码 场景： 一个数据类，用于记录职工信息 public class Employee { public String name; public int age; public char sex; pu...
std::bind与lambda表达式
alexhu2010q的博客
07-19 1316
bind-vs-lambda 参考：bind-vs-lambda 参考：why-use-stdbind-over-lambdas-in-c14 参考：Lambdas vs. std::bind in C++11 and C++14 背景介绍 In C++98, such binding was accomplished via std::bind1st and std::bind2nd. TR1 added std::tr1::bind, which was promoted to std::bind
Lambda表达式：代替std::bind的绝佳方法
尘中远的程序开发记录
04-18 6698
Lambda表达式：代替std::bind的绝佳方法 lambda表达式使得函数指针有了更灵活的使用方法，但是有些时候，对于大型的函数，还是不建议用lambda表达式，谁也不想在函数里又看到一段长长的函数。 Lambda表达式的用法在：C++11 lambda表达式在for_each和transform算法下的使用已经进行了介绍。另外我在另一篇文章利用C++11的function和bind功能
泛型约束及lambda表达式，表达式树
fc_88的专栏
06-18 1626
泛型前面说概念比较简单而且说过了，
std::function和std::bind和lambda函数
weixin_53022668的博客
11-16 955
C++中可调用对象的虽然都有一个比较统一的操作形式，但是定义方法五花八门。为程序功能实现提供多种可行方式时，也让可调用对象的统一管理变得麻烦。熟悉std::function,std::bind,lamdba函数这三把利器可以让你畅行接口世界。 std::function std::function 是一个可调用对象包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。 std::function 的实例能存储、复制及
C++ 多态
wxk2227814847的博客
07-10 512
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
python-torch加载c++与内核函数
最新发布
weixin_40777649的博客
07-11 185
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 420
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C语言-动态内存管理
m0_73605503的博客
07-07 1063
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
第10章 泛型算法1
08-03
"本章节主要介绍了泛型算法的概念，它是C++标准库中的一部分，可以应用于不同类型的容器和元素。这些算法通过迭代器进行操作，不直接改变容器的大小，但可能改变元素的值。其中提到了几个具体的算法，如find()、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值