[C++] C++11新特性介绍 分析(2): lambda表达式、function包装器、bind()接口

最新推荐文章于 2024-06-06 15:10:46 发布
最新推荐文章于 2024-06-06 15:10:46 发布
阅读量287 收藏 1
点赞数 1
分类专栏： C++语法分析 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxyt2002/article/details/131594142
版权

|wide

文章目录

C++11

上一篇介绍C++11常用的新特性只介绍了一部分. 本篇文章继续分析介绍.

lambda 表达式

C++11之前, 我们使用 std::sort() 接口对自定义类型进行排序 或者 设置降序排列, 需要使用 仿函数, 就像这样:

#include <iostream>
#include <iterator>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>

using std::cout;
using std::endl;
using std::greater;
using std::string;
using std::vector;

struct Goods {
    string _name;  // 名字
    double _price; // 价格
    int _evaluate; // 评价
    Goods(const char* str, double price, int evaluate)
        : _name(str)
        , _price(price)
        , _evaluate(evaluate)
    {}
};

// 价格升序仿函数
struct ComparePriceLess {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price < gr._price;
    }
};

// 价格降序仿函数
struct ComparePriceGreater {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price > gr._price;
    }
};

int main() {
    int array[] = {4, 1, 8, 5, 3, 7, 0, 9, 2, 6};

    // 默认按照小于比较，排出来结果是升序
    std::sort(array, array + sizeof(array) / sizeof(array[0]));
    cout << "升序" << endl;
    for (auto e : array) {
        cout << e << " ";
    }
    cout << endl << endl;

    // 如果需要降序，需要改变元素的比较规则
    std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
    cout << "降序" << endl;
    for (auto e : array) {
        cout << e << " ";
    }
    cout << endl << endl;

    vector<Goods> v = {
        {"苹果", 2.1, 5},
        {"香蕉", 3.1, 4}, 
        {"橙子", 2.2, 3}, 
        {"菠萝", 1.5, 4}
    };

    sort(v.begin(), v.end(), ComparePriceLess());
    cout << "价格升序" << endl;
    cout << "物品   价格   评价" << endl;
    for (auto e : v) {
        cout << e._name << "   " << e._price << "    " << e._evaluate << endl;
    }
    cout << endl;

    sort(v.begin(), v.end(), ComparePriceGreater());
    cout << "价格降序" << endl;
    cout << "物品   价格   评价" << endl;
    for (auto e : v) {
        cout << e._name << "   " << e._price << "    " << e._evaluate << endl;
    }
    cout << endl;

    return 0;
}

std::sort() 针对标准类型, 默认是按照降序排序的.

在上述代码中, 我们通过 标准中的仿函数 std::greater 可以让 std::sort 对数组升序排序.

而如果我们想要实现 对自定义类型进行排序, 就需要根据排序需求 定义相应的仿函数传给 std::sort() 然后才可以正确的排序.

上面代码的执行结果是:

|inlinecat

但是, 如果每次想要对不同自定义类型实现按需求排序, 那就 每次都需要定义一个满足需求的仿函数. 这样好像太麻烦了.

所以, C++11 引入了 lambda 表达式

lambda 表达式

什么是 lambda 表达式呢?

先来看一下效果:

// 其他部分还是 上面代码中的部分
void printGoods(vector<Goods>& v) {
    cout << "物品   价格   评价" << endl;
    for (auto e : v) {
        cout << e._name << "   " << e._price << "    " << e._evaluate << endl;
    }
    cout << endl;
}

int main() {
    vector<Goods> v = {
        {"苹果", 2.1, 5},
        {"香蕉", 3.1, 4}, 
        {"橙子", 2.2, 3}, 
        {"菠萝", 1.5, 4}
    };
    
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
        return g1._price < g2._price; });
    cout << "价格升序" << endl;
    printGoods(v);
    
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
        return g1._price > g2._price; });
    cout << "价格降序" << endl;
    printGoods(v);
    
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
        return g1._evaluate < g2._evaluate; });
    cout << "评价升序" << endl;
    printGoods(v);
    
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
        return g1._evaluate > g2._evaluate; });
    cout << "评价降序" << endl;
    printGoods(v);

    return 0;
}

这段代码的执行结果是:

|inline

我们没有实现仿函数, 但是依旧实现了按需求排序. 这就是因为使用了 lambda 表达式

上面的例子中, std::sort() 的第三个参数:

|inline

这些都是 lambda 表达式. 不过 并不完整, lambda 表达式的完整格式为:

[captureList] (parameters) mutable -> returnType { statement }
[]()mutable->xxx{ }

这些都表示什么意思呢?

  1. [capture-list]: 捕捉列表

    该列表总是出现在 lambda 表达式的开始位置, 编译器根据[]来判断接下来的代码是否为 lambda 表达式, 捕捉列表能够捕捉上下文中的变量供 lambda 表达式使用

  2. (parameters): 参数列表

    与 普通函数的参数列表 一致. 如果不需要参数传递, 则可以连同()一起省略

  3. mutable

    默认情况下，lambda 函数总是一个 const 函数, 即 它的捕捉的 值对象 可以被看作默认被 const 修饰. mutable 可以取消其常量性. 使用该修饰符时, 参数列表不可省略(即使参数为空)

  4. -->returnType: 返回值类型

    用 追踪返回类型形式 声明函数的返回值类型, 没有返回值时此部分可省略. 返回值类型明确情况下. 也可省略. 由编译器对返回类型进行推导

    什么是返回值类型明确的情况下?

    看一看上面的例子, 结果一定是一个 bool 所以可以省略返回值声明

    类似的情况就可以省略

  5. { statement }: 函数体

    与普通函数的编写方式相同. 但是 在此作用域内, 只能使用传入的参数 或 捕捉到的父级作用域对象.

参数列表、mutable、返回值类型 在特定情况下都可以省略

从 lambda 表达式的组成来看, 与函数非常的相似. 而实际上, lambda 表达式就是一个 匿名函数对象, 可以被称为 匿名函数, 因为它没有函数名.

且, lambda 表达式 除了可以直接匿名使用之外, 还可以这样:

int main() {
    vector<Goods> v = {
        {"苹果", 2.1, 5},
        {"香蕉", 3.1, 4}, 
        {"橙子", 2.2, 3}, 
        {"菠萝", 1.5, 4}
    };
    
    auto priceUp = [](const Goods& g1, const Goods& g2) {
        return g1._price < g2._price; };
    sort(v.begin(), v.end(), priceUp);
    cout << "价格升序" << endl;
    printGoods(v);
    
    return 0;
}

通过 auto 来对 lambda 表达式 定义一个变量. 这样 相应的 lambda 表达式 就可以通过此变量被调用.

认识了 lambda 表达式之后, 有关于 lambda 表达式的使用还有一些关于 捕捉列表 细节需要介绍.

我们使用 lambda 表达式, 尝试实现交换对象的值:

int main() {
    int a = 10, b = 20;
    cout << a << "  " << b << endl;
 
    auto lamSwap1 = [](int x, int y){
        int tmp = x;
        x = y;
        y = tmp;
    };
    auto lamSwap2 = [](int& x, int& y){
        int tmp = x;
        x = y;
        y = tmp;
    };
    lamSwap1(a, b);
    cout << "lamSwap1:: "<< a << "  " << b << endl;
    
    lamSwap2(a, b);
    cout << "lamSwap2:: "<< a << "  " << b << endl;
    
    return 0;
}

上面两个 lambda 表达式, 哪一个可以成功让 a 和 b 交换值?

一定是 lamSwap2, 因为 传入函数内的参数 如果是临时变量改变 不会影响到原数据. 而 lamSwap2 使用的是 左值引用.

|inline

直接传参可以实现交换数据.

不过我们还可以是用另外一种写法. 使用 捕捉列表

捕捉列表 描述了上下文中哪些数据可以在 lambda表达式作用域内 使用, 以及使用的方式传值还是传引用.

  1. [var]：表示值传递方式捕捉变量var
  2. [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
  3. [&var]：表示引用传递捕捉变量var
  4. [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
  5. [this]：表示值传递方式捕捉当前的this指针

具体的使用如下:

int main() {
    int a = 10, b = 20;
    cout << a << "  " << b << endl;
 
    auto lamSwap1 = [a, b](){
        int tmp = a;
        a = b;
        b = tmp;
    };
    auto lamSwap2 = [&a, &b](){
        int tmp = a;
        a = b;
        b = tmp;
    };
    lamSwap1();
    cout << "lamSwap1:: "<< a << "  " << b << endl;
    
    lamSwap2();
    cout << "lamSwap2:: "<< a << "  " << b << endl;
    
    return 0;
}

此次的两个 lambda 表达式, 哪一个可以成功让 a 和 b 交换值?

lamSwap2 肯定可以, 不过 lamSwap1 可以吗?

inline

很可惜, 这段代码编译无法通过, 并且 问题出在了 某个 lambda 表达式上.

是 lamSwap1. 我们在介绍 lambda 表达式的结构时 介绍过一个内容:

默认情况下，lambda 函数总是一个 const 函数, 即 它的捕捉的 值对象 可以被看作默认被 const 修饰. mutable 可以取消其常量性. 使用该修饰符时, 参数列表不可省略(即使参数为空)

在 lamSwap1 中, 我们捕捉的 [a, b] 就是 值对象. 所以, 此时 lamSwap1 内的 a 和 b 都是被 const 修饰的值.

所以是无法修改的. 要想在内部修改, 就要使用 mutable :

auto lamSwap1 = [a, b]()mutable{
    int tmp = a;
    a = b;
    b = tmp;
};

修改之后:

|inline

可以看到, 可以编译通过. 但是 执行之后, 值并没有被交换. 因为, lamSwap1 是 传值捕捉.

所以, 其实 mutable 这个关键词, 显得很没有用.

传值捕捉 默认const修饰, 想要修改需要使用mutable. 但是使用之后, 又因为传值捕捉, 导致无法修改实际内容. 所以 mutable 好像没有什么太大作用.

不过, 现在我们知道了 []捕捉列表 的用法. 可以捕捉 父级作用域的对象, 让其可以在 lambda 表达式内部使用.

并且, 使用 [&var] 就是传引用捕捉, [var] 就是传值捕捉.

但是, 如果想要使用父级作用域的所有对象, 如果还需要一一显式捕捉的话, 就太繁琐了

所以, C++11还设计了, 使用 [&] 就是传引用捕捉所有父级作用域内的对象, 使用 [=] 就是传值捕捉所有父级作用域内的对象

并且, C++11还设计了 混合使用. 即, 可以实现类似下面这样的捕捉:

[&, a] 			// a对象传值捕捉, 其他父级作用域内的所有对象 传引用捕捉
[=, &a]			// a对象传引用捕捉, 其他父级作用域的所有对象 传值捕捉

所以, lambda 表达式的使用, 实际上是非常灵活的.

但是, lambda 表达式 禁止重复捕捉:

[&, &a]
[&a, &a]
[=, a]
[a, a]

像类似上面的这些操作, 在某些编译器上 是会报错的:

|inline

GCC不会报错, 只会报出警告:

|wide

还有一点就是, lambda 表达式 只能捕捉父级作用域中的对象. 即 包含此 lambda 表达式的作用域

lambda 表达式底层

关于 lambda 表达式 还有一个非常重要的内容是 关于它的类型.

我们可以通过 auto 接收一个 lambda 表达式. 但是他究竟是什么呢?

lambda 表达式能不能相互赋值呢?

答案是, 不能

即使是像这样的 看起来几乎一样的 lambda 表达式, 也不能相互赋值:

int main() {
    auto f1 = []{cout << "hello world" << endl; };
    auto f2 = []{cout << "hello world" << endl; };
    f1 = f2;

    return 0;
}

|inline

但是, 可以通过 拷贝构造的形式, 创建一个 lambda 表达式的副本.

也可以, 将 lambda 表达式赋值给一个 参数和返回值类型都相同的函数指针

void (*pF)();
int main() {
    auto f1 = []{cout << "hello world" << endl; };
    
    auto f2(f1);
    f2();
    
    pF = f1;
    pF();

    return 0;
}

|inline

这就是 lambda 表达式.

这是为什么呢?

为什么会出现 这一部分现象呢? 其实是由于 lambda 的底层实现 是 仿函数.

对, 就是可以像函数一样使用的对象, 就是在类中重载了 operator()运算符 的类对象

这一点, 可以在 VS中通过反汇编代码看出来:

|inline

包装器 function

C++11 增添了 lambda 表达式之后.

C++中 可调用类型的对象就变成了三种: 函数指针, 仿函数, lambda

可以通过这三种对象 调用函数.

三种不同类型的可调用对象, 用法又非常的相似. 如果, 恰好模板有需求, 需要在不同场景 使用这三种不同类型的可调用对象, 怎么才能实现呢?

大概就像这样实现:

template<class F, class T>
T useF(F f, T x) {
	static int count = 0; 		// static 用来记录实例化出的同一个函数被执行多少次
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;

	return f(x);
}

double f(double i) {
	return i / 2;
}

struct Functor {
	double operator()(double d) {
		return d / 3;
	}
};

int main() {
	// 函数名
	cout << useF(f, 11.11) << endl;

	// 函数对象
	cout << useF(Functor(), 11.11) << endl;

	// lamber表达式
	cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;

	return 0;
}

useF() 模板中, 第一个模板参数是用来接收 可调用对象类型的.

当分别传入 函数名、函数对象、lambda 之后, 此模板会被实例化三个不同的函数:

|inline

可以发现, 在 useF() 内定义的 static 每次执行都是1, 且不同的地址.

这就说明 三次执行实例化了三个不同的 useF() 函数.

三种不同类型 传给模板, 实例化三个不同的函数, 非常的正常.

但是 这三种可调用对象的使用方式几乎一样, 通过一个模板 却需要 实例化三个不同的函数, 好像又有一点浪费.

所以, C++11 引入了 包装器

function 包装普通可调用对象

function包装器 也叫作 适配器.

C++11 之后, 设计了一个 std::function类模板, 也是一个包装器.

|inline

function 类模板:

  1. 第一个模板参数 Ret 需要传入可调用对象的返回值类型

  2. 后面则是 模板可变参数包, 需要传入 可调用对象的参数类型列表

  3. 不过, function 类模板传参 不需要向其他类模板一样, 将参数用逗号隔开

    可以直接 这样传参 function< retType(paraType1, paraType2, paraType3, ...)>

可以使用 std::function 类模板 将 不同类型的可调用对象, 包装成一个类型 即 function 类型

使用时, 需要使用 #include <functional> 包含 functional 头文件

#include <functional>

double f(double i) {
	return i / 2;
}

struct Functor {
	double operator()(double d) {
		return d / 3;
	}
};

int main() {
    // 函数名
	std::function<double(double)> func1 = f;
    cout << "未使用包装器 f 类型" << typeid(f).name() << endl;
    cout << "包装器后 类型" << typeid(func1).name() << endl << endl;

    // 函数对象
    std::function<double(double)> func2 = Functor();
    cout << "未使用包装器 Functor() 类型" << typeid(Functor()).name() << endl;
    cout << "包装器后 类型" << typeid(func2).name() << endl << endl;

    // lamber表达式
    std::function<double(double)> func3 = [](double d)->double{ return d / 4; };
    auto lam1 = [](double d)->double{ return d / 4; };
    cout << "未使用包装器 lambda 类型" << typeid(lam1).name() << endl;
    cout << "包装器后 类型" << typeid(func3).name() << endl;

	return 0;
}

这段代码的执行结果:

|inline

不用在意未使用包装器时, 究竟是什么类型. 只需要看到 使用包装器之后, 三种可调用对象的类型被统一了.

其实就是使用 不同的可调用对象 实例化了 function 对象. 都是同一个类模板, 肯定是相同的类型.

并且, 我们还可以通过 function 对象来执行 可调用对象的功能:

#include <functional>

double f(double i) {
	return i / 2;
}

struct Functor {
	double operator()(double d) {
		return d / 3;
	}
};

int main() {
    // 函数名(函数指针)
    std::function<double(double)> func1 = f;
    cout << func1(1) << endl;

    // 函数对象
    std::function<double(double)> func2 = Functor();
    cout << func2(4) << endl;

    // lamber表达式
    std::function<int(int, int)> func3 = [](const int a, const int b){ return a + b; };
    cout << func3(1, 2) << endl;

    return 0;
}

|inline

在对不同类型的 可调用对象包装之后, 可以将 function 对象, 传入给其他模板共其使用:

#include <iostream>
#include <functional>

using std::cout;
using std::endl;

template<class F, class T>
T useF(F f, T x) {
	static int count = 0; 		// static 用来记录实例化出的同一个函数被执行多少次
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;

	return f(x);
}

double f(double i) {
	return i / 2;
}

struct Functor {
	double operator()(double d) {
		return d / 3;
	}
};

int main() {
    // 函数名
    std::function<double(double)> func1 = f;
    cout << useF(func1, 11.11) << endl << endl;
    
    // 函数对象
    std::function<double(double)> func2 = Functor();
    cout << useF(func2, 11.11) << endl << endl;
    
    // lamber表达式
    std::function<double(double)> func3 = [](double d)->double{ return d / 4; };
    cout << useF(func3, 11.11) << endl;
}

这段代码的执行结果:

|inline

可以看出, 此时 useF 函数模板 只实例化出了一个函数. 因为, 同一个 count 被 ++、输出了 3 次

function 包装类内成员函数

function 包装器, 除了可以包装这三种基础的可调用对象之外. 还可以包装 类内的成员函数:

class Plus{
public:
    static int plusi(int a, int b) {
		return a + b;
	}

    double plusd(double a, double b) {
        return a + b;
    }
};

int main() {
    // 包装静态成员变量
    std::function<int(int, int)> func1 = Plus::plusi;
    cout << func1(1, 2) << endl;
    
    // 包赚非静态成员变量
    std::function<double(Plus, double, double)> func2 = &Plus::plusd;
    cout << func2(Plus(), 3.3, 4.4) << endl;
    
    return 0;
}

这段代码的执行结果是:

|inline

是可以正常执行相应的函数的.

不过, 通过观察代码 就可以发现, 包装静态成员函数 和 包装非静态成员函数 的方式是 存在不同的

静态成员函数, 因为 不存在隐含的this指针, 本身就可以直接通过类名调用, 比如 Plus::plusi(1, 2). 所以在 实例化 function 对象 进行包装时, 不用在参数中 传入一个 Plus 对象. 并且, 不需要取地址包装.

而 非静态成员函数, 由于是类内函数且非静态 第一个参数是隐含的this指针, 所以需要 通过对象调用. 所以 在进行包装时, 第一个参数是需要指定类的, 并且在使用时, 需要传入一个对象, 例子中使用了 Plus() 来传递匿名对象. 并且, 需要取地址包装.

bind()

什么是 bind() ?

|inline

C++中, bind() 是一个函数模板，它可以 接受一个可调用对象, 生成一个新的可调用对象来“适应”原对象的参数列表

什么意思呢?

直接看一个使用例子:

#include <functional>

int Sub1(int a, int b) {
    return a - b;
}

int main() {
    std::function<int(int, int)> func1 = std::bind(Sub1, std::placeholders::_1, std::placeholders::_2);
    cout << func1(4, 8) << endl;
    
    std::function<int(int, int)> func2 = std::bind(Sub1, std::placeholders::_2, std::placeholders::_1);
    cout << func2(4, 8) << endl;
    
    return 0;
}

这段代码的执行结果:

|inline

我们通过 std::bind() 绑定了 Sub1() 函数, 并将其包装.

不过, std::bind() 的参数传递, 有一些差别. 导致 包装之后的 函数的执行结果不同.

bind() 使用 及 功能

那么, bind() 的功能究竟是什么呢?

1. 调整参数位置

相信大多数人看不懂上面的例子的原因是因为 std::placeholders::_1 和 std::placeholders::_2. 第一个参数容易理解, 就是需要 bind() 的可调用对象.

那么 std::placeholders::_n 是什么意思呢?

解释之前, 先来看一张图, 看完图或许可以直接理解:

|big

看了还是不理解. 那就要 再介绍一下 bind() 的作用了.

接受一个可调用对象, 生成一个新的可调用对象来“适应”原对象的参数列表

bind() 的第一个参数, 就是接受的可调用对象. 而 后面的 std::placeholders::_n 其实表示的是 可调用对象对应的参数

std::placeholders::_1, 表示 可调用对象的第一个参数

std::placeholders::_2, 表示 可调用对象的第二个参数

std::placeholders::_3, 表示 可调用对象的第三个参数, 以此类推.

那么在上述例子中:

  1. std::bind(Sub1, std::placeholders::_1, std::placeholders::_2)

    _1 表示Sub1()的第一个参数, _2 表示Sub1()的第一个参数

    那么, bind() 执行之后, 获得的函数就是 Sub1(int a, int b), 函数体不变.

  2. std::bind(Sub1, std::placeholders::_2, std::placeholders::_1)

    同样的, _1 表示Sub1()的第一个参数, _2 表示Sub1()的第一个参数

    那么, 此次 bind() 执行之后, 获得的函数就是 Sub1(int b, int a), 函数体不变.

Sub1() 的函数体是 reutn b - a;

当我们执行 func1(4, 8), func1() <==> Sub1(int a, int b), 所以 结果是 8 - 4 = 4

当我们执行 func2(4, 8), func2() <==> Sub2(int b, int a), 所以 结果是 4 - 8 = -4

所以, std::placeholders::_n 强绑定了 所接受的可调用对象的参数的位置. bind() 后面的参数, 表示了 bind() 执行之后的可调用对象的参数位置

2. 绑定参数

类的非静态成员函数, 因为第一个参数默认为this指针 且无法更改. 所以 在包装时, 需要将包装的函数的第一个参数类型 指明为类. 且在使用时需要传入一个对象.

而 bind() 的作用是 接受一个可调用对象, 生成一个新的可调用对象来“适应”原对象的参数列表

所以, 我们还可以使用 bind(), 将 类的对象 绑定在类的成员函数上, 以便之后使用时 不在手动传入对象:

#include <functional>

class Sub {
public:
    int sub(int a, int b) {
        return a - b;
    }
};

int main() {
    Sub s;
    // 绑定成员函数
    std::function<int(int, int)> func = std::bind(&Sub::sub, s, placeholders::_1, placeholders::_2);
	cout << func(3, 4) << endl;
    
    return 0;
}

这段代码的执行结果:

|inline

std::bind(&Sub::sub, s, placeholders::_1, placeholders::_2) 通过 在 this 指针的位置 直接传入一个对应类对象.

包装时 就不用在相应位置指定类, 包装之后, 使用包装完成的对象执行可调用对象, 也不用再显式传入一个类对象.

这 才是 bind() 真正常用的功能. 调整参数位置 相应的没有那么常用.

而且, 通过此功能还可以了解到, std::placeholders::_n 占位符 是不包括 this 指针的.

七月.cc
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
浅析C++11新特性的Lambda表达式
09-01
C++11 新增了很多特性，lambda 表达式是其中之一，本文涉及到C++11这次更新中较为重要的lambda表达式。有需要的朋友们可以参考学习。
结合C++11新特性来学习C++中lambda表达式的用法
09-02
主要介绍了C++中lambda表达式的用法,lambda表达式的引入可谓是C++11中的一大亮点,同时文中也涉及到了C++14标准中关于lambda的一些内容,需要的朋友可以参考下
c++11 function、bind()、lambda
小liu向bei的博客
06-08 192
function： C++11提供的一个类模板，用来包装各种形式类型的可调用实体（函数指针，普通函数，函数对象，lambda表达式，bind绑定的对象） 绑定成员函数：function<返回类型（类名&，参数列表）> func = &类名::成员函数 bind(): 可以看作函数适配器，可以把可调用对象和现有的参数先绑到一块，生成一个新的可调用实体，可用function接收。 作用：可以把含多元参数的可调用对象转成一元、二元、少元的可调用对象。 在使用一些STL算法的时候，比如f
C++谓词、lambda与bind
Cooper的博客
05-27 287
谓词、lambda与bind定制操作lambda表达式参数绑定 定制操作 学习STL标准库过程中，了解到许多算法都会比较序列中的元素，甚至有些容器自带都会比较元素的顺序(如SET) 一般而言，这类算法使用元素类型的重载运算符(operate <==)来完成元素之间的比较。 为了方便我们根据实际需求来完成排序，STL允许我们提供自己定义的操作来代替默认运算符 举个栗子，比方说我们有一个string类型的vector容器,其中含有以下几个单词 “foxes”,“yellow”,“theme” ,“o
C++lambda表达式及bind函数总结
qq_39540537的博客
09-16 606
目录 引入lambda 值捕获 使用捕获列表 参数绑定 标准库bind函数 绑定check_size的sz参数 以下是对阅读<<C++Primer (第5版)>>lambda阅读部分总结 在实际的编程过程中,对于某些函数,我们希望对于传入的参数列表,其中某些参数是固定的值,而另外一个参数随着调用次数的增长而传入一个像STL容器一样的可迭代对象,对象的值随着*iterator值得不同而改变,每次调用该函数后会执行iterator++,并再次通过相同的传入参数调用该函数。
C++11 Lambda表达式和bind
yuleidnf的博客
01-13 1084
Lambda捕获列表 1、空，没有使用任何函数对象参数。 2、=，函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。 3、&，函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用...
C++ Primer笔记——lambda表达式与bind函数
weixin_61857742的博客
12-20 1119
lambda是C++11所规定的一种新方法。一般用于泛型算法传递自定义函数。[ 捕捉列表 ] ( 参数列表 ) ->返回值类型 { 函数体 }lambda表达式会返回一个函数对象。};f(a, b);等价于下列函数{}//按降序排序});使用lambda表达式时，1.捕捉列表可以为空2.尾置返回类型和参数列表可以忽略，即[]{};3.捕捉列表和函数体不能忽略。
C++11：lambda表达式及function包装器
decade777555的博客
05-04 929
Lambda表达式是一种在C++11中引入的功能，允许我们定义匿名函数。它的语法比较简洁，可以方便地在需要函数对象的地方使用，例如STL算法、线程、智能指针等。
06 C++11 std::function、std::bind、lambda表达式
Snow__Sunny的博客
10-21 344
C++11 std:function std::bind lambda
C++11中lambda、std::function和std:bind详解
08-31
大家都知道C++11中增加了许多的新特性，下面在这篇文中我们就来聊一下lambda表达式，闭包，std::function以及std::bind。文中介绍的很详细，相信对大家具有一定的参考价值，有需要的朋友们下面来一起看看吧。
C++11新特性：Lambda表达式.pdf
10-20
C++11新特性：Lambda表达式.pdf
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
Ddddddd_158的博客
06-04 320
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
C语言——指针
weixin_45725380的博客
05-31 795
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
C++候捷stl-视频笔记2
Mhypnos的博客
05-31 816
候捷stl标准库学习笔记
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 448
数学 构造
c++实战知识点
qq_24867003的博客
06-03 1044
如果一个函数既可以用全局变量也可以用静态局部变量满足该函数要求，优先考虑静态局部变量，因为更安全。- 假如我们需要的参数越来越多，那么普通函数所需要的参数也就会越来越多，我们的框架(算法findif)也需要一同修改，这个不符合代码规范。如果函数的实参不是左值或与const引用形参的类型不匹配，那么c++将创建正确类型的匿名变量，将实参的值传递给匿名变量，让形参来引用该变量。重载的operator new 和 operator delete函数都是静态函数，因此无法使用类的普通成员变量。
STL使用小记
qq_38690917的博客
05-31 296
增大或缩小容器实际存储的元素的数量resize只会改变实际存储的元素的数量，并不会改变容器的最大容量，即容器的capacity1、如果resize指定的值小于当前容器的实际存储的元素的数量，则多出来的元素都会被删除（2、如果大于当前容器的实际存储的元素数量，则会添加新的元素进行补充，按照指定的值或者容器进行值初始化。
STL中stack和queue模拟实现+容器适配器
最新发布
2202_75331338的博客
06-06 693
deque（双端队列）：是一种双开口的“连续”空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素，与list比较，空间利用率比较高。deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组双端队列底层是一段假象的连续的空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在看deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示；
c++11中lambda、std::function和std:bind详解
06-06
Lambda表达式是一种匿名函数定义方式，std::function是一种通用的可调用对象包装器，std::bind是一种可绑定参数的函数包装器。 Lambda表达式定义了一种可以直接使用的函数对象，可以使用[ ]符号指定其捕获变量，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

七月.cc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值