匿名函数 lambda函数

lambda语法

所谓lambda是一份功能定义式，可被定义于语句(statement)或表达式(expression)内部。因此你可以拿lambda当作inline函数使用。

最小型的lambda函数没有参数，什么也不做，如下：

[]{
	std::cout<< "hello lambda" <<std::endl;
}
可以直接调用它：

[]{
	std::cout<<"hello lambda" <<std::endl;
}(); //prints "hello lambda"

或者把它传递给对象，使之能被调用：

auto l=[]{
		std::cout<<"hello lambda"<<std::endl;
	};

l(); //prints “hello lambda”

如你所见，lambda总是由一个所谓的lambda introducer引入：那是一组方括号，你可以在其内指明一个所谓的capture，用来在lambda内部访问”nonstatic外部对象“。如果无需访问外部数据，这组方括号可以为空。Static对象，诸如cout，是可被使用的。

在lambda introducer 和lambda body之间，你可以指明参数或mutable，或一份异常明细（exception specification）或attribute specifier以及返回类型。所有这一切都可有可无，但如果其中一个出现了，参数所需的小括号就必须出现。 因此lambda语法也可以是：[…] {…}或[…] (…)。

Lambda 可以拥有参数，指明于小括号内，就像任何函数一样：

auto l=[](const std::string& s){
		std::cout<<s<<std::endl;
};
l("hello lambda");

然而，请注意，lambda不可以是template，你始终必须指明所有类型。

lambda也可以返回某物。但你不需要指明返回类型，该类型会根据返回值被推导出来。例如下面的lambda的返回类型是int：

[]{
	return 42;	
}

如果一定想指明一个返回类型，可使用新式C++语法

[]() -> double{
	return 42;
}

会返回42.0
这里指明返回类型，放在实参所需要的小括号以及 字符->以后

下面是一个lambda表达式的使用用例：

auto num=[](const int & n){
			return n;
		};
	
	auto n=num(2);
	cout<<n<<endl;

输出结果：2

Capture（用以捕获外部作用域的数据）

在lambda introducer（每个lambda最开始的方括号）内，你可以指明一个capture用来捕获外部作用域内未被传递为实参的数据，lambda捕获方式主要有三种：值捕获、引用捕获和隐式捕获。

值捕获

值捕获的前提是变量可以拷贝，与传值参数不同的是，被捕获的变量是在lambda创建时拷贝，而不是在调用时拷贝。

void f() {
	int i = 5;
	auto ff = [i] {return i;};  // 将i拷贝到可调用对象ff中
	i = 0;
	auto j = ff();  // j为5，而非0，因为ff保存了创建时i的拷贝
}

引用捕获

引用捕获的前提确保被引用的对象在lambda表达式执行时还是存在的。

void print(vector<string> w, ostream &os=cout, char c = ' ') {
	// os只能通过引用的方式进行捕获；c是通过值捕获的方式
	// 打印数据
	for_each(w.begin(), w.end(), [&os, c] (const string &s) {
		os << s << c;
	});
}

隐式捕获

在捕获列表中使用 &或 = 即表示隐式捕获，指示编译器自动推断捕获列表，& 表示采用引用捕获的方式，= 表示采用值捕获的方式。

// sz采用隐式值捕获的方式
auto wa = find_if(w.begin(), w.end(), [=](const string &s) {
	return s.size() >= sz;
});

// os使用隐式引用捕获方式
for_each(w.begin(), w.end(), [&] (const string &s) {
	os << s;
});

混合使用隐式捕获和显式捕获

1. 混合使用隐式捕获和显式捕获时，要求捕获列表中第一个元素必须是隐式捕获（&或=）。
2. 混合使用时，若隐式捕获采用引用捕获 &，则显式捕获的变量必须采用值捕获的方式。
3. 若隐式捕获采用值捕获 = ，则显式捕获的变量必须采用引用捕获的方式。

示例：

void print(vector<string> w, ostream &os=cout, char c='a') {
	// os使用隐式引用捕获方式; c必须是显式的值捕获方式
	for_each(w.begin(), w.end(), [&, c] (const string &s) {
		os << s << c;
	});
	
	// c使用隐式值捕获方式; os必须是显式的引用捕获方式
	for_each(w.begin(), w.end(), [=, &os] (const string &s) {
		os << s << c;
	});
}

lambda函数的优点

在开始正文之前，我们先看一个问题，对下面的vector进行排序：

std::vector<int> v = {1, 3, 2};

在C++11之前，我们可能会这么做(普通函数，即函数指针作为参数)：

bool Compare(int a, int b) {
  return a < b;
}

int main() {
  std::vector<int> v = {1, 3, 2};
  std::sort(v.begin(), v.end(), Compare);
  
  return 0;
}

也有可能这样做(函数对象，即类对象作为参数)：

int main() {
  struct Compare {
    bool operator()(int a, int b) {
      return a < b;
    }
  };
  std::vector<int> v = {1, 3, 2};
  std::sort(v.begin(), v.end(), Compare());

  return 0;
}

但是上述两种方式均有其局限性：对于普通函数的实现方式来说，其优点具有最小的语法开销，缺点是必须在使用作用域外进行定义。对于类对象的实现方式来说，其优点可以在作用域内进行定义，但缺点是需要有类定义的语法开销。lambda既保持了二者的优点，又摒弃了二者的缺点。