C++中的匿名函数（译）

C++11最令人兴奋的特性之一就是能够创建匿名函数（lambda functions），有时也被称为闭包（closures）。这意味着什么？lambda function是一个可以内联写在代码里的函数（通常被传递给另一个函数，与函数对象（functor）和函数指针有相似的概念）。有了lambda，快速创建函数已经变得更容易，也意味着不仅可以在之前需要定义一个独立的命名函数时使用lambda function，而且也可以凭借快速创建简单的函数写出更多的代码。本文中我会先解释为什么lambda是很棒的，并会给出一些例子，然后简略阐述使用lambda时你所可以做的所有细节。

为什么lambdas让人震撼

假使有一个地址簿类，而且想要提供一个搜索方法。你可以提供一个简单的搜索函数，接受一个string作为参数并返回所有与该string参数相匹配的地址。有时是该类的用户所想要的，但要是他们仅想在域名中搜索，或更可能在用户名中搜索且忽略掉在域名中的结果呢？或许他们可能想要搜索所有同时出现在另一个列表中的邮件地址，有许多潜在地待搜索的感兴趣的事情。代替把这些所有的选择都构建到类里，岂不是更好提供一个接受确定邮件地址是否是感兴趣的过程作为参数的通用find方法？我先称该方法为findMatchingAddresses，且接受一个函数或类函数参数。

#include <string>
#include <vector>
class AddressBook {
public:
// using a template allows us to ignore the differences between functors, functon
// pointers and lambda
template<typename Func>
std::vector<std::string> findMatchingAddresses(Func func) {
std::vector<std::string> results;
for (auto iter = _addresses.begin(), end = _addresses.end(); iter != end; iter++) {
// call the function passed into findMatchingAddresses and see if it matches
if (func(*iter)) {
results.push_back(*iter);
}
}
return results;
}
private:
std::vector<std::string> _addresses;
};

任何人都可以都可以传递一个函数给findMatchingAddresses，该函数是一个包含查找逻辑的特殊函数。当给出一个特定地址时，如果该函数返回true，则返回该地址。在早期的C++版本中这种方式是可以的，但是有一个严重的缺点：不能方便的创建函数。你需要在一个地方定义，然后为了一次简单的使用要是它能够被传递进来。那就是lambas出现的地方。

基本lambda语法

在写代码解决该问题之前，先看一下lambda基本的语法。

#include <iostream>
using namespace std;
int main()
{
auto func = []() { cout << "Hello world" << endl; };
func(); // now call the function
}

注意到了以[]开始的lambda了吗？那个标识符被称为捕获说明(capture specification)，用于告诉编译器穿件一个lambda function。你将会看到它（或一个变种）在每一个lambda function的开始处。

接下来，像其他的函数一样有一个参数列表：()。返回值在哪？事实说明不需要给出一个返回值。在C++11中，如果编译器可以推断lambda function的返回值，它将会进行推断而不需要你给出一个返回值。在这个例子里，编译可以知道函数无返回值。接着就是函数体，输出“hello world”。然后这行代码实际上不会输出任何东西，这里仅是创建了一个函数。几乎像定义一个普通的函数，仅仅是内联余下的代码。

在仅接下来的一行调用lambda function: func()，这看起来和调用其他任何函数一样。顺便地注意auto使其变得多么的容易。你不再需要对函数指针这种丑陋的语法而烦恼。

使用lambda

让我们先看下怎样应该它到我们的地址簿的例子中，首先创建一个简单的函数，用于查找包含.org的邮件地址。

Addressbook global_address_book;
vector<string> findAddressesFromOrgs()
{
return global_address_book.findMatchingAddresses(
// we're declaring a lambda here; the [] signals the start
[](const string &addr) { return addr.find(".org") != string::npos; }
);
}

再次，我们以捕获标识符（capture specifier）[]开始，但这次我们有一个参数--地址，检查它是否包含".org"。仍然在lambda function的函数体内没有什么会被执行；它仅仅是在findMatchingAddresses中，当func被使用时，lambda function中的代码会执行。

也就是说，通过findMatchingAddresses的每次循环，都会调用lambda function且给它一个地址作为参数，然后检查是否含有".org"。

lambdas的变量捕获

尽管lambda这些简单的使用是吸引人的，但变量捕获（variable capture）才是真正的秘密武器（secret sauce），它使得lambda function变得强大。假使你想要创建一个查找包含特定名字的地址的小函数，是不是会更好把代码写长像这样？

// read in the name from a user, which we want to search
string name;
cin >> name;
return global_address_book.findMatchingAddresses(
// notice that the lambda function uses the variable 'name'
[&](const string& addr) { return addr.find(name) != string::npos; }
);

事实上这个例子是完全合法的，而且它展现出lambda的真正价值。我们可以接受一个lambda外的变量声明(name)，而在lambda内使用它。当findMatchingAddresses调用我们的lambda function时，在其内部的所有代码执行，当addr.find被调用时，它可以访问用户传入的name。为使它起作用所需要做的唯一的事就是让编译器知道我们所想要的变量捕获。我所做的就是使用[&]进行捕获说明，而不是[]。[]告诉编译器不需要捕获任何变量，而[&]告诉编译器执行变量捕获。

是不是很不可思议？我们可以创建一个带有捕获的变量名的简单函数，将它传递给find方法，所有的仅写在一行代码里。没有C++11要得到相似的行为，我们或者需要创建一个函数对象，或者在类AddressBook中需要一个特定的方法。在C++11中，我们可以有一个单一简单的接口相对于AddressBook，它可以真正简单地支持任何种类的过滤。

只为好玩（just for fun），假如说我们想要查找一个邮件地址，其长度不长于某个给定的字符数。可以简单地这样做：

int min_len = 0;
cin >> min_len;
return global_address_book.findMatchingAddresses([&](const string &addr) { return addr.length() >= min_len;});

顺便说一下，从Herb Sutter盗用的，你应该习惯看到（you should get used to seeing）“});”。这是标准的lambda函数结尾语法，你看到和在自己代码里使用lambda越多，你越会看到越多的小部分语法。

Lambda和STL

lambda functions的最大受益者之一毫无疑问标准模板库算法包的大量用户。先前，使用像for_each这样的算法是很别扭的实践。现在几乎可以像写一个普通循环一样使用for_each和其它STL算法。相对比：

vector<int> v;
v.push_back(1);
v.push_back(2);
for (auto it = v.begin(), end = v.end(); it != end; it++) {
cout << *it;
}

和

vector<int> v;
v.push_back(1);
v.push_back(2);
for (auto it = v.begin(), end = v.end(); it != end; [](int val) {
cout << val;
});

代码开看起来很漂亮，读起来像是被结构化的普通循环，突然你就能够使用for_each在普通循环之上提供的优势，如保证有正确的结束条件。你可能想知道是否会影响性能？很重要的事(here's the kicker)：for_each与普通循环有相同的性能，有时甚至更高（因为它可以利用循环展开（loop unrolling）的优势）。

如果想了解更多的C++11 lambda和STL的益处，你将会喜欢Herb Sutter讨论C++11的视频。

我希望这个STL的例子能够向你展现出lambda function不仅仅是能简单的创建函数--它们允许你完全形成写程序的新方式，像在那些把其它函数作为数据和允许提取出特殊数据结构进行处理的代码。for_each作用在列表上和作用在树上有相似的函数岂不是很好，所需要做的就是确定将要处理的每个节点是正常的节点，而不需要担心遍历算法？这种分解一个函数处理数据结构和另一个函数被委托处理数据的方式是很强大的。有了lambda，C++可以使用这种方式编程。当然不是以前不能这样做，for_each算法也并不是新的，而仅仅是以前不想这样做。

怎样实现Lambda闭包

变量捕获的魔力怎样真正起作用的？事实上lambda是通过创建一个小的类的方法实现的，这个类重载了operator()，以便看起来就像是一个函数。lambda function就是该类的一个实例；当类被创建好后，周围环境内的任何变量都会被传递给lambda function class的构造函数，并保存为成员变量。事实上与函数对象的概念有点类似。C++11的优势使这样做起来变得很容易--所以可以随时使用它，而不是仅仅在那些罕见的情况下要写一个完整的有意义的新类。

鉴于对性能的敏感，C++对于捕获什么变量和怎样捕获给出了很大的灵活性，所有都通过捕获说明[]进行控制。前面已经看过两种情况--[]不捕获任何变量和[&]以引用捕获所有的变量。如果你用一个空捕获说明创建lambda，C++会创建一个普通函数而不是创建一个类。以下是捕获选项列表：

[] 不捕获变量（or，a scorched earch strategy?）
[&] 以引用方式捕获变量
[=] 以值方式捕获变量
[=,&foo] 以值方式捕获变量，除了以引用方式捕获变量foo
[bar] 仅捕获变量bar
[this] 捕获包围类的this指针

注意最后的捕获选项--如果指定了=或&，就默认捕获了this指针就不需要再包含它，然而可以捕获一个函数的this指针是相当重要的，因为这意味着在写lambda functions时不需要区分局部变量和类的成员变量，两者都可以访问。你不需要显示使用this指针，就像是在写内联函数，多么酷的一件事。

class Foo {
public:
Foo() : _x(3) {}
void func() {
// a very silly, but illustrative way of printing out the value of _x
[this]() { cout << _x; }();
}
private:
int _x;
};
int main()
{
Foo f;
f.func();
}

引用捕获的风险和益处

在使用引用捕获时，lambda functions能够修改lambda之外的局部变量--毕竟是引用。但这同时也意味着如果从一个函数返回一个lambda function，你就不能使用引用捕获，因为在函数返回后所引用的变量将是无效的。

Lambda是什么类型？

我们已经看到可以使用模板来接受一个lambda function作为参数，而auto也可以把一个lambda function作为局部变量。但应该怎样命名一个特定的lambda呢？由于每个lambda function都是通过创建一个单独的类实现的，正如之前所见，甚至单个lambda function也是不同的类型--即使两个函数有相同的参数和返回值！但是C++11包含了一个方便的包装器（wrapper），可以存储任何类型的函数--lambda function，functor，function pointer： std::function。

std::function

这个新的std::function是一种很棒的方式，用于传递lambda function作为参数和返回值。它允许在模板中指定确切的参数类型和返回值类型。AddressBook 的例子，这次使用std::function代替模板，注意需要包含functional头文件：

#include <functional>
#include <vector>
class AddressBook {
public:
std::vector<string> findMatchingAddresses (std::function<bool (const string&)> func) {
std::vector<string> results;
for ( auto itr = _addresses.begin(), end = _addresses.end(); itr != end; ++itr ) {
// call the function passed into findMatchingAddresses and see if it matches
if ( func( *itr ) ) {
results.push_back( *itr );
}
}
return results;
}
private:
std::vector<string> _addresses;
};

std::function相对于模板最大的优势是写一个模板需要把整个函数放到头文件中，而std::function不需要。这可能会真的有些帮助如果你工作在有许多需要待修改的代码而且还被包含在许多源文件中。

如果想要检查std::function类型的变量是否拥有一个有效函数，可以将其像一个boolean类型一样对待：

std::function<int ()> func;
// check if we have a function (we don't since we didn't provide one)
if (func) {
// if we did have a function, call it
func();
}

关于函数指针的注记

根据最终的C++11标准，如果lambda的捕获说明是空的，那么它可以被看作为一个普通函数且可以赋值给一个函数指针。下面是一个无捕获lambda使用函数指针的例子：

typedef int (*func)();
func f = []() -> int { return 2; };
f();

一个无捕获的lambda不需要属于自己的类，它可以被编译成一个普通的老式函数，允许它像一个一般的函数被传递。MSVC10不支持。

用lambdas创建委托

看一个更复杂的lambda function例子--这次创建一个委托。什么是委托？在调用普通函数时，你所需要的就是函数自身。当在一个对象上调用方法时，你需要两个东西：函数和对象本身。func()和obj.method()是不同的。调用一个方法，你需要两个，仅仅传递一个方法的地址给函数时不够的，需要在一个对象上调用方法。

看例子，以期望一个函数作为参数的代码，在里面我们会传递一个委托：

#include <functional>
#include <string>
class EmailProcessor {
public:
void receiveMessage(const std::string &message) {
if (_handler_func) {
_handler_func(message);
}
// other processing
}
void setHandlerFunc(std::function<void (const std::string&)> handler_func) {
_hanlder_func = handler_func;
}
private:
std::function<void (const std::string&)> _handler_func;
};

这是很标准的模型，允许一个回调函数被注册到一个类中。

而现在我们想要另一个类负责跟踪目前收到的最长消息。总之，我们可以像这样创建一个小类：

#include <string>
class MessageSizeStore {
public:
MessageSizeStore() : _max_size(0) {}
void checkMessage(const std::string& message) {
const int size = message.length();
if (size > _max_size) {
_max_size = size;
}
}
int getSize() { return _max_size; }
private:
int _max_size;
};

应如何让checkMessage方法无论何时有消息到达都被调用？我们不能仅传递checkMessage本身--它是一个方法，需要一个对象。

EmailProcessor processor;
MessageSizeStore size_store;
processor.setHandlerFunc(checkMessage); // this won't work

我们需要某种方式绑定变量size_store到被传递给setHandlerFunc的函数。听起来像是lambda的工作！

EmailProcessor processor
MessageSizeStore size_store;
processor.setHandlerFunc([&](const std::string& message) {
size_store.checkMessage(message);
});

是不是很酷？我们使用lambda function作为胶水代码，传递给了setHandlerFunc一个普通函数，还是在方法之上做了一个调用--在C++中创建了一个简单的委托。

结论

这门语言已经存在了几十年，lambda function会真的开始到处出现在C++代码中吗？我认为是的，我已经在产品级代码中使用lambda，而且他们也在到处出现--在某些缩减代码的情况，某些改进单元测试的情况和替换先前使用宏所完成的情况。我认为lambda比任何希腊字母都让人震撼。

来源：oschina

链接：https://my.oschina.net/u/2314428/blog/780614

标签

返回值

lambda

匿名函数

string

vector

const