C++11（下）

最新推荐文章于 2024-09-01 20:13:17 发布

-杀意感知-

最新推荐文章于 2024-09-01 20:13:17 发布

阅读量955

点赞数 15

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/2301_77525727/article/details/141060714

版权

c++ 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

九、lambda 表达式

1、C++98 中的一个例子

在 C++98 中，如果想要对一个数据集合中的元素进行排序，可以使用 std::sort 方法。


#include <algorithm>
#include <functional>
int main()
{
    int array[] = {4,1,8,5,3,7,0,9,2,6};
    // 默认按照小于比较，排出来结果是升序
    std::sort(array, array+sizeof(array)/sizeof(array[0]));
    // 如果需要降序，需要改变元素的比较规则
    std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
    return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则：

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()
{
    vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
}

随着 C++ 语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。
因此，在 C++11 语法中出现了 Lambda 表达式。

2、lambda 表达式


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

上述代码就是使用 C++11 中的 lambda 表达式来解决，可以看出 lambda 表达式实际是一个匿名函数。

3、lambda 表达式语法

lambda 表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement }

（1）lambda 表达式各部分说明

[capture-list]： 捕捉列表 ，该列表总是出现在lambda函数的开始位置，编译器根据 [] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
(parameters)：参数列表 。与普通函数的参数列表一致，如果不需要参数传递，则可以连同 () 一起省略。
mutable：默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。使用该修饰符时，参数列表不可省略（即使参数为空）。
returntype： 返回值类型 。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}： 函数体 。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：在 lambda 函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
因此 C++11 中最简单的 lambda 函数为： [ ]{ }; 该 lambda 函数不能做任何事情。

int main()
{
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
    []{}; 
    
    //局部匿名函数
    auto add1 = [](int x, int y)->int {return x + y; };
    cout << add1(1, 2) << endl;//3
    
    auto func1 = []()->int 
    {
    	cout << "hello bit" << endl;
    	cout << "hello sy" << endl;
        return 0;
    };
    func1();
    
    return 0;
}

通过上述例子可以看出，lambda 表达式实际上可以理解为无名函数，该函数无法直接调
用，如果想要直接调用，可借助 auto 将其赋值给一个变量。

（2）捕获列表说明

int main()
{
	int a = 0, b = 1;
	auto swap1 = [](int& x, int y)
	{
		//只能用当前lambda局部域和捕捉的对象
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap1(a, b);
	//捕捉a,b
	//如果不加mutable就无法改变捕捉过来的a, b
	//同时加了mutable就不能省略参数列表，即使没有参数
	auto swap2 = [a, b]()mutable
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	swap();

上述 swap2 所说其实只是捕捉列表中一种，传值捕捉，本质是一种拷贝，并且const修饰了，加上mutable相当于去掉了const属性，可以修改了，但是修改了不会影响外面被捕捉的值，因为是一种拷贝

下面详细列举所有种类：

[var]：表示值传递方式捕捉变量 var。
[=]：表示值传递方式捕获所有父作用域中的变量（包括 this）。
[&var]：表示引用传递捕捉变量 var。
[&]：表示引用传递捕捉所有父作用域中的变量（包括this）。
[this]：表示值传递方式捕捉当前的 this 指针。

int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	//所有值传值捕捉
	auto func1 = [=]
	{
		int ret = a + b + c + d;
		return ret;
	};
    //所有值传引用捕捉
	auto func2 = [&]
	{
		 a++;
		 b++;
		 c++;
		 d++;
		 int ret = a + b + c + d;
		 return ret;
    };
	//混合捕捉
	auto func3 = [&a, b]
	{
		a++;
		//b不能修改
		int ret  = a + b;
		return ret;
	};

	//混合捕捉
	//所有值以引用方式捕捉， d用传值捕捉
	auto func4 = [&, d]
	{
		a++;
		b++;
		c++;
		//d++,d不能修改
		int ret = a + b + c + d;
		return ret;
	};

	auto func5 = [=, &d]
	{
		//a++;
		//b++;
		//c++;
		d++; 
		int ret = a + b + c + d;
		return ret;
	};

注意：

父作用域指包含lambda函数的语句块。
语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量 a 和 b，值传递方式捕捉其他所有变量 [&，a, this]：值传递方式捕捉变量 a 和 this，引用方式捕捉其他变量。
捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉 a 重复。
在块作用域以外的 lambda 函数捕捉列表必须为空。
在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
lambda 表达式之间不能相互赋值，即使看起来类型相同。

void (*PF)();
int main()
{
 auto f1 = []{cout << "hello world" << endl; };
 auto f2 = []{cout << "hello world" << endl; };
    // 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
 //f1 = f2;   // 编译失败--->提示找不到operator=()
    // 允许使用一个lambda表达式拷贝构造一个新的副本
 auto f3(f2);
 f3();
 // 可以将lambda表达式赋值给相同类型的函数指针
 PF = f2;
 PF();
 return 0;
}

4、函数对象与 lambda 表达式

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了 operator() 运算符的类对象。

class Rate
{
public:
    Rate(double rate): _rate(rate)
    {}
 
    double operator()(double money, int year)
    {
        return money * _rate * year;
    }
 
private:
    double _rate;
};
 
int main()
{
    // 函数对象
    double rate = 0.49;
    Rate r1(rate);
    r1(10000, 2);
 
    // lamber
    auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
    r2(10000, 2);
    return 0;
}

lambda与引用类似，引用在语法上是新的东西，但底层就是指针。lambda被引入C++语法，lambda被编译了以后，会生成一个对应的仿函数。对于我们来说是匿名的，所以要auto，但对于编译器来说是有名字的，是编译器自己生成的
在这里插入图片描述

不同的lambda类型是不一样的，用lambda_uuid区分
在这里插入图片描述

十、包装器

1、function包装器

（1）function包装器的介绍

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。

function类模板的原型如下：

template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：

Ret：被包装的可调用对象的返回值类型。
Args…：被包装的可调用对象的形参类型。

包装示例如下：
function包装器可以对可调用对象进行包装，包括 函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。比如：

int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator()(int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	//1、包装函数指针（函数名）
	function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	//2、包装仿函数（函数对象）
	function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;

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

	//4、类的静态成员函数
	//function<int(int, int)> func4 = Plus::plusi;
	function<int(int, int)> func4 = &Plus::plusi; //&可省略
	cout << func4(1, 2) << endl;

	//5、类的非静态成员函数
    //写法一：
    function<double(Plus*, double, double)> func5 = &Plus::plusd; //&不可省略
    Plus pd;
    cout << func5(&pd, 1.1, 2.2) << endl;

    //写法二：
    function<double(Plus, double, double)> func5 = &Plus::plusd;
	cout << func6(pd, 1.1, 2.2) << endl;//可以传有名对象
	cout << func6(Plus(), 1.1, 2.2) << endl;//可以传匿名对象
	return 0;
}

注意事项：

包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。传的第一个参数可以是指针也可以是对象，因为本质是用这个指针或者对象去调用这个函数plusd

（2）function包装器统一类型

对于以下函数模板useF：

传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数。

代码如下：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	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;

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

由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。

但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
这时就可以 用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。

代码如下：

int main()
{
	//函数名
	function<double(double)> func1 = func;
	cout << useF(func1, 11.11) << endl;

	//函数对象
	function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;

	//lambda表达式
	function<double(double)> func3 = [](double d)->double{return d / 4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次。

（3）function包装器简化题目代码

题：求解逆波兰表达式的步骤如下：

定义一个栈，依次遍历所给字符串。
如果遍历到的字符串是数字则直接入栈。
如果遍历到的字符串是加减乘除运算符，则从栈定抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式的计算结果。

class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		for (const auto& str : tokens)
		{
			int left, right;
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				right = st.top();
				st.pop();
				left = st.top();
				st.pop();
				switch (str[0])
				{
				case '+':
					st.push(left + right);
					break;
				case '-':
					st.push(left - right);
					break;
				case '*':
					st.push(left * right);
					break;
				case '/':
					st.push(left / right);
					break;
				default:
					break;
				}
			}
			else
			{
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

在上述代码中，我们通过switch语句来判断本次需要进行哪种运算，如果运算类型增加了，比如增加了求余、幂、对数等运算，那么就需要在switch语句的后面中继续增加case语句。

这种情况可以用包装器来简化代码。

建立各个运算符与其对应需要执行的函数之间的映射关系，当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。
当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可。

代码如下：

class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		map<string, function<int(int, int)>> opFunMap = {
			{ "+", [](int a, int b){return a + b; } },
			{ "-", [](int a, int b){return a - b; } },
			{ "*", [](int a, int b){return a * b; } },
			{ "/", [](int a, int b){return a / b; } }
		};
		for (auto& str : tokens)
		{
			//if (str == "+" || str == "-" || str == "*" || str == "/")
			if(opFunMap.count(str))
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				int ret = opFunMap[str](left,right);
				st.push(ret);
			}
			else
			{
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

需要注意的是，这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定。

（4）function包装器的意义

将可调用对象的类型进行统一，便于我们对其进行统一化管理。
包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

2、bind包装器

（1）bind包装器介绍

bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。

bind函数模板的原型如下：

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

模板参数说明：

fn：可调用对象。
args…：要绑定的参数列表：值或占位符。

调用bind的一般形式为：auto newCallable = bind(callable, arg_list);

解释说明：

callable：需要包装的可调用对象。
newCallable：生成的新的可调用对象。
arg_list：逗号分隔的参数列表，对应给定的callable的参数。当调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置，比如 _1为newCallable的第一个参数，_2为第二个参数，以此类推。

_1, _2的介绍： 用_1,_2的标识符代替参数
同时要写成placeholders::_1, placeholders::_2，或者uing placeholders::_1;前置声明一下

在这里插入图片描述

此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。

（2）bind包装器绑定固定参数

无意义的绑定

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//无意义的绑定
	function<int(int, int)> func = bind(Plus, placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //3
	return 0;
}

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，所以说这是一个无意义的绑定。

绑定固定参数
如果想把Plus函数的第二个参数固定绑定为10，可以在绑定时将参数列表的placeholders::_2设置为10。比如：

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//绑定固定参数
	function<int(int)> func = bind(Plus, placeholders::_1, 10);
	cout << func(2) << endl; //12
	return 0;
}

此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。

如果是sub，将第一个参数固定绑定为100，则原本的第二个参数就成了第一个参数

如图所示：
在这里插入图片描述

（3）bind包装器调整传参顺序

对于下面Sub类中的sub成员函数，sub成员函数的第一个参数是隐藏的this指针，如果想要在调用sub成员函数时不用对象进行调用，那么可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//绑定固定参数
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //-1
	return 0;
}

此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给this指针。

如果想要将sub成员函数用于相减的两个参数的顺序交换，那么直接在绑定时将placeholders::_1和placeholders::_2的位置交换一下就行了。比如：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//调整传参顺序
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	cout << func(1, 2) << endl; //1
	return 0;
}

根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。

bind包装器的意义

将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
可以对函数参数的顺序进行灵活调整。

-杀意感知-

关注

15
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
C++11（下）

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。Ret：被包装的可调用对象的返回值类型。Args…：被包装的可调用对象的形参类型。function包装器可以对可调用对象进行包装，包括函数指针（函数名）仿函数（函数对象）lambda表达式类的成员函数。public:class Pluspublic:int main()//1、包装函数指针（函数名）//2、包装仿函数（函数对象）
复制链接

扫一扫