原创文章，转载请注明： 转载自：严健康的个人博客 http://www.yanjiankang.cn/
本文链接地址: http://www.yanjiankang.cn/cpp_11_new_feature/
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
#include
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
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
//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
int
source
[
5
]
=
{
0
,
12
,
34
,
50
,
80
}
;
int
target
[
5
]
;
//从 source 拷贝 5 个元素到 target
copy_n
(
source
,
5
,
target
)
;
//iota() 算法可以用来创建递增序列，它先把初值赋值给 *first，然后用前置 ++ 操作符增长初值并赋值到给下一个迭代器指向的元素，如下
#include
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。
转载请保留原文链接。本文内容均为实践后的学习整理，本人拥有所有解释权。如本文侵犯了你的版权，请联系作者[email protected]进行删除。