C++11 lambda表达式和包装器

C++11引入的语法当中
除了STL库当中的区别,还有几个很常用的语法
就是我们今天要介绍的lambda表达式和function包装器
(bind包装器不是特别常用,但是我们有些时候也可能会用到,因此我们也介绍一下)

一.lambda表达式

1.lambda表达式的引入

我们之前学习过函数指针和仿函数,它们都是一种回调函数
只不过仿函数的语法更加简单明了

但是仿函数有一个缺点:
实现它必须要定义一个类出来
例如:
我们要实现一个比较算法,对不同的商品按照价格分别升序和降序排序

#include <iostream>
using namespace std;
#include <algorithm>//sort的头文件
#include <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& left, const Goods& right)
    {
        return left._price < right._price;
    }
};

//按照价格降序
struct ComparePriceGreater
{
    bool operator()(const Goods& left, const Goods& right)
    {
        return left._price > right._price;
    }
};

int main()
{
    vector<Goods> v = { { "苹果", 2.5, 5 }, { "香蕉", 3.2, 4 }, { "橙子", 2.9, 3 }, { "菠萝", 1.5, 4 } };
    sort(v.begin(),v.end(), ComparePriceLess());
    for (auto& e : v)
    {
        cout << "商品名称: " << e._name << " 价格 :" << e._price << " 评价:" << e._evaluate << endl;
    }
    cout << endl;
    sort(v.begin(), v.end(), ComparePriceGreater());
    for (auto& e : v)
    {
        cout << "商品名称: " << e._name << " 价格 :" << e._price << " 评价:" << e._evaluate << endl;
    }
    cout << endl;
    return 0;
}

我们发现,仅仅是需要分别按照价格升序和降序排序就需要单独写两个类出来
那么如果我又有需求了:分别按照评分升序和降序等等…
那样的话还要再写几个类
而且仿函数的命名上面也有问题,
刚才我们命名的是ComparePriceLess和ComparePriceGreater
如果有人这么命名呢?
Compare1,Compare2…
那样的话代码可读性就很差了

因此C++11引入了lambda表达式来解决这一问题
我们先来用lambda表达式取代一下刚才的仿函数

int main()
{
    vector<Goods> v = { { "苹果", 2.5, 5 }, { "香蕉", 3.2, 4 }, { "橙子", 2.9, 3 }, { "菠萝", 1.5, 4 } };
    //按照价格升序
    sort(v.begin(), v.end(), [](const Goods& left, const Goods& right)
        {
            return left._price < right._price;
        });
    for (auto& e : v)
    {
        cout << "商品名称: " << e._name << " 价格 :" << e._price << " 评价:" << e._evaluate << endl;
    }
    cout << endl;
    //按照价格降序
    sort(v.begin(), v.end(), [](const Goods& left, const Goods& right)
        {
            return left._price > right._price;
        });
    for (auto& e : v)
    {
        cout << "商品名称: " << e._name << " 价格 :" << e._price << " 评价:" << e._evaluate << endl;
    }
    cout << endl;
    return 0;
}

此时我们每次调用sort的时候只需要传入一个lambda表达式
即可指明比较方式,大大简化代码并且提高了代码的可读性

2.基本语法和使用

1.基本语法

//按照价格升序
sort(v.begin(), v.end(), [](const Goods& left, const Goods& right)
{
    return left._price < right._price;
});

根据这个排序我们可以看出

lambda表达式的底层就是一个匿名函数
该函数无法直接调用,如果想要直接调用,可借助auto将其赋值给一个对象,用那个对象来调用

小例子:

lambda表达式中的捕捉列表可以捕捉上下文中的变量
被捕捉到的变量可以被lambda表达式使用,而且我们可以设置捕捉的方式是传值还是传引用

2.使用

下面我们用lambda表达式实现一下int类型的swap函数

1.传值捕捉的错误之处

int main()
{
    int a = 1, b = 2;
    //这里传值捕捉了a和b,所以后面调用myswap时无需传参
    auto myswap = [a, b]()
    {
        int tmp = a;
        a = b;
        b = tmp;
    };
    myswap();
    cout << "交换后 : " << " a: " << a <<" b: " << b << endl;
    return 0;
}

所以我们要加上mutable

可是交换之后a还是1,b还是2啊?
为什么?
因为我们是传值捕捉,形参的改变不会影响实参
因此mutable的意义就是提醒我们
1.如果你想要改变实参,请你传引用捕捉,传值捕捉的话改变的是形参不是实参
2.如果你不想改变实参,传值捕捉的话,需要加上mutable提醒别人这里是传值捕捉,不会影响实参

2.传引用捕捉

方案1:传值捕获a和b,参数列表无需传参

方案2:捕获列表不去捕获,参数列表传引用传参

3.lambda表达式的底层原理

其实lambda表达式的底层原理就是仿函数,对operator()进行了重载
就像是范围for的底层原理就是迭代器一样

struct Myswap
{
    void operator()(int& a, int& b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }
};
int main()
{
    int a = 1, b = 2;
    //这里捕获列表不去捕获,参数列表需要传参
    auto myswap = [](int& a,int& b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    };
    int x = 9;//为了方便调试打断点看反汇编
    Myswap myswap2;
    myswap2(a, b);
    myswap(a,b);
    return 0;
}

这是因为每个lambda表达式的类型是不同的
(在VS下,lambda会被处理为函数对象,该函数对象对应的类名叫做<lambda_uuid>)

关于uuid
大家感兴趣的话可以百度一下
UUID

4.lambda的特殊之处

lambda不支持直接调用默认构造来构造对象
但是支持拷贝构造对象

5.lambda配合decltype的新玩法

sort是传入函数对象即可,可是对于priority_queue这种需要传入类的容器来说,lambda就没有用武之地了吗?
并不是的

//建一个小堆(注意:优先级队列:默认是大堆配less,小堆配greater)
auto f = [](int a, int b) {return a > b; };

priority_queue<int, vector<int>, decltype(f)> minheap(f);

二.function包装器

1.概念

2.包装函数

下面我们来使用一下function包装器
头文件是<functional>

1.包装普通函数

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

//1.函数
int add1(int a, int b)
{
	return a + b;
}

//2.仿函数
struct Add2
{
	int operator()(int a, int b)
	{
		return a + b;
	}
};

int main()
{
	//1.包装函数指针
	function<int(int, int)> f1;
	f1 = add1;
	cout << f1(1, 2) << endl;

	//2.包装仿函数
	function<int(int, int)> f2 = Add2();//Add2():匿名对象
	cout << f2(1, 2) << endl;

	//3.包装lambda表达式
	function<int(int, int)> f3 = [](const int a, const int b) {return a + b; };
	cout << f3(1, 2) << endl;
	return 0;
}

2.包装成员函数

可见:包装器的本质就是对各种可调用对象进行类型的统一

3.包装器的另一个应用:统一模板实例化的类型

//传入该函数模板的第一个参数可以是任意可调用对象:函数指针,仿函数,lambda表达式
//func中定义了静态变量count,每次调用时打印count的值和地址,可以用来判断多次调用时所调用的是否是用一个func函数
template<class A,class T>
T func(A a, T b)
{
	static int count = 0;
	cout << "count值: " << ++count << endl;
	cout << "count地址: " << &count << endl;
	return a(b);
}

//传入第二个参数相同的类型,但是传入的可调用对象的类型是不同的
//那么在编译阶段该模板函数就会被实例化多次
struct Func1
{
	double operator()(double d)
	{
		return d / 2;
	}
};

double func2(double d)
{
	return d / 2;
}

int main()
{
	//函数
	cout << func(func2, 2.2) << endl;
	//仿函数
	cout << func(Func1(), 2.2) << endl;
	//lambda表达式
	cout << func([](double d)->double {return d / 2; }, 2.2) << endl;
	return 0;
}

尽管三次调用传入的可调用对象的类型不同,
但是这三次调用对象的返回值和形参类型相同

因此我们就可以使用包装器来对这三个不同的可调用对象来进行包装,此时就可以只实例化一份func函数了

4.小小总结

function包装器可以统一可调用对象的类型
包装后明确了可调用对象的返回值和形参类型,更加方便使用者进行使用

三.bind包装器

1.概念

头文件:functional

2.bind包装器绑定固定参数

bind绑定可以跟function包装器集合使用

1.无意义绑定

int Add(int a, int b)
{
	return a + b;
}

int main()
{
	//绑定函数Add,参数分别由调用func1的第一,二参数来指定
	function<int(int, int)> func1 = bind(Add, placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;
	return 0;
}

2.绑定固定参数

3.bind包装器调整传参顺序

我们以Sub类为例


同理,普通函数也是如此

以上就是C++11 lambda表达式和包装器的全部内容,希望能对大家有所帮助!