C++11 -- lambda表达式

lamaba表达式的引入

• 在C++11之前,如果我们想对自定义类型Goods排序,可以根据姓名,价格,学号按照从大到小或者从小到大的方式排序,可是,这样我们要写额外写6个相关的仿函数.
• 并且我们在对自定义仿函数命名的过程中,很容易会因为命名不规范造成代码解读麻烦,无法通过仅仅通过仿函数名字了解实际功能,只能重新去查找对应的函数名的仿函数去了解实际功能.

struct Goods
{
	string _name;  //名字
	double _price; //价格
	int _num;      //数量
};

struct ComparePriceLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};
struct CompareNumLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num < g2._num;
	}
};
struct CompareNumGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num > g2._num;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2, 20 }, { "香蕉", 3, 30}, { "橙子", 4,40 }, { "菠萝", 5,50 } };
	sort(v.begin(), v.end(), ComparePriceLess());    //按Goods价格升序排序
	sort(v.begin(), v.end(), ComparePriceGreater()); //按Goods价格降序排序
	sort(v.begin(), v.end(), CompareNumLess());      //按Goods升序排序
	sort(v.begin(), v.end(), CompareNumGreater());   //按Goods降序排序
	return 0;
}

在C++11后,我们便可以通过lamada表达式来解决,lamada表达式实际上就是一个匿名函数,这样我们即可通过lamada表达式直接了解sort排序的比较方式,进而提高了代码的可读性.

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	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._num < g2._num; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._num < g2._num; });
	return 0;
}

lambda表达式语法

lamada表达式的书写格式:

[capture-list] (parameters) mutable -> return-type 
{  
  statement
}

lamabda达式各部分说明

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

lambda表达式的简单运用

int mian()
{
	//由于lambda表达式实际上就是一个匿名对象,没有函数名不好调用,但是我们可以通过auto自动获取.
	auto add1 = [](int a, int b) { return a + b; };    //省略返回值.

	cout << add1(1, 2) << endl;

}

捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式为传值还是传引用.

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

lambda表达式中未使用捕获列表和使用捕获列表对比.

如果我们不适用捕获列表,我们就要额外写函数形参,在调用时也必须将实参传过去,这样过于麻烦.

int main()
{
	//之前做法
	int x = 0,y = 1;
	
	auto swap1 = [](int& x1, int& x2) { int tmp = x1; x1 = x2; x2 = tmp;};

	swap1(x, y);

	return 0;
}

所以,我们可以使用捕获列表,又因为传值捕获过来的x,y通常是不可以被修改的(可以使用mutable修饰符),并且此时捕获过来的x,y仅仅为实参的拷贝,此时,我们一般采用引用捕捉,这样让代码更加简洁.

int main()
{
	auto swap2 = [&x, &y] {int tmp = x; x = y; x = tmp;}; //引用捕捉.
    
	swap2();             //不需要传递实参.
	
	cout << x << ":" << y << endl;
	
}

捕捉列表其他特性的简单运用

int main()
{
	int a, b, c, d, e;
	
	auto f1 = [=] {cout << a << b << d << e; }; //a,b,c,d,e全部传值捕获.

	f1();

	auto f2 = [=, &a] { a++; cout << a << b << c << d << e; }; //b,c,d,e传值捕获,a传引用捕获.

	f2();
	
}

但是注意,捕获列表不允许变量重复传递,否则就会导致编译错误.

int main()
{
	int a, b, c, d, e;
	
	auto f = [=,a] {cout << a << b << d << e; }; //重复捕获.

}

lamaba表达式底层原理探索

编译器对于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表达式完全一样,函数对象将rate作为其成员变量，在定义对象时传递实参即可,lambda表达式通过捕获列表可以直接将该变量捕获到实参传过去。
• 从底层实现的方式来看,完全就是按照仿函数的方式处理,当我们定义一个lambda表达式时,编译器就会主动生成一个仿函数,并且,为了方便处理,编译器都要通过UUID的方式基本生成一个唯一的仿函数名.然后在调用的时候通过lambda表达式调用这个仿函数,该仿函数又调用操符重载operator().所以实际上,捕获列表捕获到的变量传递给了operator()后在函数体内实现.