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;
});
混合使用隐式捕获和显式捕获
- 混合使用隐式捕获和显式捕获时,要求捕获列表中第一个元素必须是隐式捕获(&或=)。
- 混合使用时,若隐式捕获采用引用捕获 &,则显式捕获的变量必须采用值捕获的方式。
- 若隐式捕获采用值捕获 = ,则显式捕获的变量必须采用引用捕获的方式。
示例:
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既保持了二者的优点,又摒弃了二者的缺点。