Lambda 表达式
Lambda 表达式就是用于创建匿名函数的。
为什么说 lambda 表达式如此激动人心呢?举一个例子。标准 C++ 库中有一个常用算法的库,其中提供了很多算法函数,比如 sort() 和 find()。这些函数通常需要提供一个“谓词函数 predicate function”。所谓谓词函数,就是进行一个操作用的临时函数。比如 find() 需要一个谓词,用于查找元素满足的条件;能够满足谓词函数的元素才会被查找出来。这样的谓词函数,使用临时的匿名函数,既可以减少函数数量,又会让代码变得清晰易读。
1 2 |
[capture](parameters)->return-type {body} |
最简单的例子如下:
1 2 3 4 5 6 7 8 9 10 |
#include <algorithm> #include <cmath> void abssort(float *x, unsigned N) { std::sort(x, x + N, [](float a, float b) { return std::abs(a) < std::abs(b); }); } |
其中需要注意:
1. 返回值类型->return-type可以省略,由语言自动推导,但前提是只有当 lambda 表达式中的语句“足够简单”,才能自动推断返回值类型。
2. 引入 lambda 表达式的前导符是一对方括号,称为 lambda 引入符(lambda-introducer)。lambda 表达式可以使用与其相同范围 scope 内的变量。这个引入符的作用就是表明,其后的 lambda 表达式以何种方式使用(正式的术语是“捕获”)这些变量(这些变量能够在 lambda 表达式中被捕获,其实就是构成了一个闭包)。
3. 捕获类型可以以下类型:
* [] // 不捕获任何外部变量
* [=] // 以值的形式捕获所有外部变量
* [&] // 以引用形式捕获所有外部变量
* [x, &y] // x 以传值形式捕获,y 以引用形式捕获
* [=, &z]// z 以引用形式捕获,其余变量以传值形式捕获
* [&, x] // x 以值的形式捕获,其余变量以引用形式捕获
4. 对于[=]或[&]的形式,lambda 表达式可以直接使用 this 指针。但是,对于[]的形式,如果要使用 this 指针,必须显式传入:
5. 对于下面的例子,[=]意味着,lambda 表达式以传值的形式捕获外部变量。C++ 11 标准说,如果以传值的形式捕获外部变量,那么,lambda 体不允许修改外部变量,对 f0 的任何修改都会引发编译错误。但是,注意在 lambda 表达式前声明了mutable关键字,这就允许了 lambda 表达式体修改 f0 的值。因此不会报错。但由于是传值的,虽然在 lambda 表达式中对 f0 有了修改,但由于是传值的,外部的 f0 依然不会被修改。
1 2 3 4 |
float f0 = 1.0; std::cout << [=](float f) mutable { return f0 += std::abs(f); } (-3.5); std::cout << '\n' << f0 << '\n'; |
– 混合机制的实例如下(f0 通过引用被捕获,而其它变量,比如 f1 则是通过值被捕获):
1 2 3 4 5 |
float f0 = 1.0f; float f1 = 10.0f; std::cout << [=, &f0](float a) { return f0 += f1 + std::abs(a); } (-3.5); std::cout << '\n' << f0 << '\n'; |
C++引入Lambda的最主要原因:
1)可以定义匿名函数;
2)编译器会把其转成函数对象;为什么以前STL中的ptr_fun()这个函数对象不能用?(ptr_fun()就是把一个自然函数转成函数对象的)原因是,ptr_fun() 的局限是其接收的自然函数只能有1或2个参数。
3)”闭包”,限制了别人的访问,更私有;
自动类型推导和 decltype
在 C++03 中,声明对象的同时必须指明其类型,其实大多数情况下,声明对象的同时也会包括一个初始值,C++11 在这种情况下就能够让你声明对象时不再指定类型了。
1 2 3 4 5 |
auto x = 0; //0 是 int 类型,所以 x 也是 int 类型 auto c = 'a'; //char auto d = 0.5; //double auto national_debt = 14400000000000LL;//long long |
这个特性在对象的类型很大很长的时候很有用,如:
1 2 3 4 5 6 |
void func(const vector<int> &vi) { //vector<int>::const_iterator ci=vi.begin(); auto ci=vi.begin(); } |
C++11 也提供了从对象或表达式中“俘获”类型的机制,新的操作符 decltype 可以从一个表达式中“俘获”其结果的类型并“返回”:
1 2 3 4 |
const vector<int> vi; typedef decltype (vi.begin()) CIT; CIT another_const_iterator; |
注意: auto作为函数返回值时,只能用于定义函数,不能用于声明函数
统一的初始化语法
C++ 最少有 4 种不同的初始化形式,如下所示:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
//括号内初始化 std::string s("hello"); int m=int(); //default initialization
//等号形式的 std::string s="hello"; int x=5;
//对于 POD 集合,又可以用大括号 int arr[4]={0,1,2,3}; struct tm today={0};
//最后还有构造函数的成员初始化: struct S { int x; S(): x(0) {} }; |
C++11 就用大括号一统天下了:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class C { int a; int b; public: C(int i, int j); }; C c {0,0}; //C++11 only. 相当于 C c(0,0); int* a = new int[3] { 1, 2, 0 }; /C++11 only class X { int a[4]; public: X() : a{1,2,3,4} {} //C++11, 初始化数组成员 }; |
对于容器来说,终于可以摆脱 push_back() 调用了,C++11中可以直观地初始化容器了:
1 2 3 4 5 6 |
// C++11 container initializer vector vs<string>={ "first", "second", "third"}; map singers = { {"Lady Gaga", "+1 (212) 555-7890"}, {"Beyonce Knowles", "+1 (212) 555-0987"}}; |
而类中的数据成员初始化也得到了支持:
1 2 3 4 5 6 7 |
class C { int a=7; //C++11 only public: C(); }; |
deleted 函数和 defaulted 函数
1 2 3 4 5 6 |
struct A { A()=default; //C++11 virtual ~A()=default; //C++11 }; |
=default; 指示编译器生成该函数的默认实现。这有两个好处:一是让程序员轻松了,少敲键盘,二是有更好的性能。
与 defaulted 函数相对的就是 deleted 函数, 实现 non copy-able 防止对象拷贝,要想禁止拷贝,用 =deleted 声明一下两个关键的成员函数就可以了:
1 2 3 4 5 6 7 8 9 10 11 |
int func()=delete;
//防止对象拷贝的实现 struct NoCopy { NoCopy & operator =(const NoCopy &) = delete; NoCopy(const NoCopy &) = delete; }; NoCopy a; NoCopy b(a); //编译错误,拷贝构造函数是 deleted 函数 |
nullptr
nullptr 是一个新的 C++ 关键字,它是空指针常量,它是用来替代高风险的 NULL 宏和 0 字面量的。nullptr 是强类型的,所有跟指针有关的地方都可以用 nullptr,包括函数指针和成员指针:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void f(int); //#1 void f(char *);//#2 //C++03 f(0); //调用的是哪个 f? //C++11 f(nullptr) //毫无疑问,调用的是 #2
const char *pc=str.c_str(); //data pointers if (pc != nullptr) cout << pc << endl; int (A::*pmf)()=nullptr; //指向成员函数的指针 void (*pmf)()=nullptr; //指向函数的指针 |
##** 委托构造函数**
C++11 中构造函数可以调用同一个类的另一个构造函数:
1 2 3 4 5 6 7 8 9 |
class M //C++11 delegating constructors { int x, y; char *p; public: M(int v) : x(v), y(0), p(new char [MAX]) {} //#1 target M(): M(0) { cout << "delegating ctor"<< end; } //#2 delegating } |
右值引用
在 C++03 中的引用类型是只绑定左值的,C++11 引用一个新的引用类型叫右值引用类型,它是绑定到右值的,如临时对象或字面量。
增加右值引用的主要原因是为了实现 move 语义。与传统的拷贝不同,move 的意思是目标对象“窃取”原对象的资源,并将源置于“空”状态。当拷贝一个对象时,其实代价昂贵且无必要,move 操作就可以替代它。如在 string 交换的时候,使用 move 意义就有巨大的性能提升,如下所示:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//原方案很慢,因为需要申请内存,然后拷贝字符; [cpp] view plain copy void naiveswap(string &a, string & b) { string temp = a; a=b; b=temp; }
//使用move就只需要交换两个数据成员,无须申请、释放内存和拷贝字符数组; void moveswapstr(string& empty, string & filled) { //pseudo code, but you get the idea size_t sz=empty.size(); const char *p= empty.data(); //move filled's resources to empty empty.setsize(filled.size()); empty.setdata(filled.data()); //filled becomes empty filled.setsize(sz); filled.setdata(p); } |
要实现支持 move 的类,需要声明 move 构造函数和 move 赋值操作符,如下:
1 2 3 4 5 6 |
class Movable { Movable (Movable&&); //move constructor Movable&& operator=(Movable&&); //move assignment operator }; |
C++11 的标准库
除 TR1 包含的新容器(unordered_set, unordered_map, unordered_multiset, 和unordered_multimap),还有一些新的库,如正则表达式,tuple,函数对象封装器等。下面介绍一些 C++11 的标准库新特性:
线程库
C++11 提供了 thread 类,也提供了 promise 和 future 用以并发环境中的同步,用 async() 函数模板执行并发任务,和 thread_local 存储声明为特定线程独占的数据, C++11 线程库教程(英文)
新的智能指针类
C++98 定义的唯一的智能指针类 auto_ptr 已经被弃用,C++11 引入了新的智能针对类 shared_ptr 和 unique_ptr。它们都是标准库的其它组件兼容,可以安全地把智能指针存入标准容器,也可以安全地用标准算法“倒腾”它们。
新的算法
主要是 all_of()、any_of() 和 none_of(),下面是例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//all_of()、any_of() 和 none_of()函数 #include <algorithm> //C++11 code //are all of the elements positive? all_of(first, first+n, ispositive()); //false //is there at least one positive element? any_of(first, first+n, ispositive());//true // are none of the elements positive? none_of(first, first+n, ispositive()); //false
//新的 copy_n: #include <algorithm> int source[5]={0,12,34,50,80}; int target[5]; //从 source 拷贝 5 个元素到 target copy_n(source,5,target);
//iota() 算法可以用来创建递增序列,它先把初值赋值给 *first,然后用前置 ++ 操作符增长初值并赋值到给下一个迭代器指向的元素,如下 #include <numeric> int a[5]={0}; char c[3]={0}; iota(a, a+5, 10); //changes a to {10,11,12,13,14} iota(c, c+3, 'a'); //{'a','b','c'} |
auto 关键字
auto实际上实在编译时对变量进行了类型推导,所以不会对程序的运行效率造成不良影响。另外,似乎auto并不会影响编译速度,因为编译时本来也要右侧推导然后判断与左侧是否匹配。
序列for循环
在C++中for循环可以使用类似java的简化的for循环,可以用于遍历数组,容器,string以及由begin和end函数定义的序列(即有Iterator),示例代码如下:
1 2 3 4 5 6 |
map<string, int> m{{"a", 1}, {"b", 2}, {"c", 3}}; for (auto p : m){ cout << p.first << " : " << p.second << endl; } |
##** nullptr**
引入nullptr的原因,这个要从NULL说起。对于C和C++程序员来说,一定不会对NULL感到陌生。但是C和C++中的NULL却不等价。NULL表示指针不指向任何对象,但是问题在于,NULL不是关键字,而只是一个宏定义(macro)。
在C中,习惯将NULL定义为void*指针值0:
1 2 |
#define NULL (void*)0 |
在C++中,NULL却被明确定义为整常数0:
1 2 3 4 5 6 7 8 9 |
// lmcons.h中定义NULL的源码 #ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif |
为什么C++在NULL上选择不完全兼容C?
根本原因和C++的重载函数有关。C++通过搜索匹配参数的机制,试图找到最佳匹配(best-match)的函数,而如果继续支持void*的隐式类型转换,则会带来语义二义性(syntax ambiguous)的问题。
如果我们的编译器是支持nullptr的话,那么我们应该直接使用nullptr来替代NULL的宏定义。正常使用过程中他们是完全等价的。
nullptr 能够转换成任何指针类型(包括成员函数指针和成员变量指针)和bool类型(这是为了兼容普通指针都能使用 if(ptr) 判断是否为空指针的形式),但是不能被转换为整数0。