C++11——lambda表达式

Posted 两片空白

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++11——lambda表达式相关的知识,希望对你有一定的参考价值。

目录

前言

一.lambda表达式用法

二.lambda表达式语法

 三.lambda表达式的原理


前言

        在显示生活中,我们在用手机购物时。总是可以在页面上看到下面这样的选项。

        我们知道底层这是通过排序来完成的,但是当我们实现时,要写多个排序算法,写多个仿函数来实现不同变量的比较。

比如下面代码:

struct CompareNameSmall;
struct CompareNameBig;
struct ComparePriceSmall;
struct ComparePriceBig;

class Goods{
	friend struct CompareNameSmall;
	friend struct CompareNameBig;
	friend struct ComparePriceSmall;
	friend struct ComparePriceBig;

private:
	string _name;
	double _price;
public:
	Goods(string name, double price)
		:_name(name)
		,_price(price)
	{}
			
};

//仿函数
struct CompareNameSmall{
	bool operator()(const Goods& g1, const Goods& g2){
		return g1._name < g2._name;
	}
};
struct CompareNameBig{
	bool operator()(const Goods& g1, const Goods& g2){
		return g1._name > g2._name;
	}
};
struct ComparePriceSmall{
	bool operator()(const Goods& g1, const Goods& g2){
		return g1._price < g2._price;
	}
};
struct ComparePriceBig{
	bool operator()(const Goods& g1, const Goods& g2){
		return g1._price > g2._price;
	}
};


int main(){
	Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };

	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameSmall());
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameBig());
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceSmall());
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceBig());

	system("pause");
	return 0;
}

随着C++的发展,人们开始觉得上面的写法太复杂了。每次为了实现一个比较算法,都需要重新定义一个类,如果每次的比较逻辑不一样,还要实现多个类,特别是在相同类的命名上。并且如果不能达到见名知义,我们还得去找对应的仿函数,才能知道它的功能,这给编程者带来了极大的不便。

        因此在C++11语法中出现了lambda表达式。

一.lambda表达式用法

class Goods{

public:
	string _name;
	double _price;

	Goods(string name, double price)
		:_name(name)
		, _price(price)
	{}

};


int main(){
	Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };
    //使用lambda表达式

	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name < g2._name; });
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name > g2._name; });
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price < g2._price; });
	sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price > g2._price; });

	system("pause");
	return 0;
}

 可以实现和上面一样的效果。虽然一样要写这么多函数,但是不需要面临去定义很多类和命名问题,并且不需要在去找函数。

但是我们发现lambda表达式的格式还是很奇怪的,下面来介绍一下lambda表达式的写法。

二.lambda表达式语法

lambda表达式书写格式:[捕捉列表](参数)mutable—>返回值类型{ 函数体 } 

  • [捕捉列表]:该列表总是出现在lambda表达式的起始位置,编译器根据[]来判断接下来的代码是否为lambda表达式,捕捉列表能够捕捉当前作用域中的变量,供lambda函数使用。
    • [val]:表示以传值方式捕捉变量val
    • [=]:表示以传值方式捕捉当前作用域中的变量,包括this指针。
    • [&val]:表示以引用方式传递捕捉变量val。
    • [&]:表示以引用方式传递捕捉当前作用域中的所有变量,包括this指针。
    • [this]:表示以传值方式捕捉当前的this指针。
  • (参数):参数列表。与普通函数参数列表使用相同。如果不需要传递参数,可以连同"()"一起省略。
  • mutable:默认情况下,lambda函数总是一个const函数,捕捉的传值参数具有常性,mutable可以取消常性。使用mutable修饰符时,参数列表不能省略,即使参数为空。
  • —>返回值类型:返回值类型。使用追踪返回类型形式声明函数的返回值类型,没有返回值此部分可省略。返回值类型明确的情况下,也可省略,由编译器推导。
  • {函数体}:在函数体内除了可以使用参数外,还能使用捕捉的变量。

注意:在lambda表达式中,参数列表和返回值类型都可省略,而捕捉列表和函数体可以为空。所以最简单的lambda表达式为:[]{},该表达式不能做任何事。

int main(){
	//最简单的lambda表达式
	[]{};

	//捕捉当前作用域的变量,没有参数,编译器推导返回值类型。
	int a = 1;
	int b = 2;
	[=]{return a + b; };

	//使用和仿函数差不多
	auto fun1 = [&](int c){b = a + c; };
	fun1(10);
	cout << a << " " << b << endl;

	auto fun2 = [&](int c)->int{return a + c; };
	fun2(20);
	cout << fun2(20) << endl;

	//传值捕捉
	int x = 1;
	int y = 2;
	auto add0 = [x, y]()mutable->int{ x *= 2;//捕捉传递传值具有常性
									return x + y; };
	cout << add0() << endl;

	auto add1 = [&x, y]()->int{ x *= 2;//捕捉传递引用不具有常性
							return x + y; };
	cout << add1() << endl;

	auto add2 = [](int s, int m)->int{ s *= 2;//参数不具有常性
								return s + m; };
	system("pause");
	return 0;
}

        从上面要注意的一点是:捕捉列表传值传递具有常性,要加mutable,传引用传递不具有常性,参数列表不具有常性。

捕捉列表的要和捕捉参数变量名相同,传值传递是当前作用域变量的拷贝。

int main(){
	//最简单的lambda表达式
	[]{};

	//捕捉当前作用域的变量,没有参数,编译器推导返回值类型。
	int a = 1;
	int b = 2;

	//auto fun1 = [x, y]()->int{return x + y; };//编译错误,要和捕捉参数名相同
	//传值传递是捕捉变量的拷贝,实际外面的a,b没有交换
	auto swap1 = [a, b]()mutable{int z = a; a = b; b = z; };
	swap1();//注意还需要调用
	cout << a << " " << b << endl;

	//传引用才能真正修改
	auto swap2 = [&a, &b]{int z = a; a = b; b = z; };
	swap2();
	cout << a << " " << b << endl;
	return 0;
}

 注意构造完对象后,对象调用,函数才起作用。

注意点:

  • 语法上捕捉列表可由多个捕捉项组成,并以逗号隔开。捕捉项不能重复传递,否则会导致编译错误。比如:当前作用域已经有了变量a,捕捉设为[=,a],=已经捕捉过a了,编译时会报错。
  • 捕捉列表只能捕捉当前作用域的局部变量,作用域以外的局部变量或者非局部变量都会报错。
  • 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;

}

 三.lambda表达式的原理

        首先我们先来比较一下仿函数和lambda表达式

        我们发现仿函数的使用和lambda表达式差不多。

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表达式原理:实际编译器在全局作用域自动生成了一个类,在类中重载了operator(), operator()函数的内容就是lambda表达式的内容。

        可以理解成lambda表达式底层还是仿函数。本来时要程序员编写,现在变成了编译器自动生成,我们看起来跟方便了。

 

以上是关于C++11——lambda表达式的主要内容,如果未能解决你的问题,请参考以下文章

C++11——lambda表达式

什么是 C++11 中的 lambda 表达式?

[C++11]lambda表达式语法

IntelliJ:求值lambda表达式在调试时引发编译错误

c++中lambda表达式用法

c++中lambda表达式用法