C++11

全文目录

• {}列表初始化
• • initializer_list
• 声明
• • auto
  • decltype
• nullptr
• STL中一些变化
• 右值引用
• • 左值引用和右值引用的区别
  • 左值引用与右值引用比较
  • 移动构造和移动赋值
  • 模板的万能引用和完美转发
• 类的新功能
• • 新的类的成员函数
  • 强制生成和删除默认成员函数
• 可变参数模板
• • emplace 和 insert
• lambda表达式
• • 函数对象与lambda表达式
• 包装器
• • function包装器
  • bind

{}列表初始化

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

int x1 = 1;
int x2{ 2 };
int array1[]{ 1, 2, 3, 4, 5 };
int array2[5]{ 0 };
Point p{ 1, 2 };
// C++11中列表初始化也可以适用于new表达式中
int* pa = new int[4]{ 0 };
1
2
3
4
5
6
7

initializer_list

STL容器同样支持：

vector<int> a { 1, 2, 3, 4, 5 };
list<int> b { 1, 2, 3, 4, 5 };
a = {10, 20, 30};
1
2
3

这是因为所有的容器都重载了initializer_list 构造函数和initializer_list 赋值运算符重载：

initializer_list参考文档

使用map通过initializer_list进行赋值时，需要注意key的const属性

声明

auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int i = 10;
auto p = &i;
auto pf = strcpy;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map::iterator it = dict.begin();
auto it = dict.begin();
1
2
3
4
5
6

decltype

关键字decltype将变量的类型声明为表达式指定的类型

const int x = 1;
double y = 2.2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p; 	// p的类型是int*
1
2
3
4

decltype跟auto不一样，auto是根据结果来推导，decltype是根据变量类型来推导。

nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
1
2
3
4
5
6
7

STL中一些变化

都支持了initializer_list 的初始化，同时新增了几个容器：

用橘色圈起来是C++11中的一些几个新容器

array： 为了规范数组的使用，同时加强了越界检查。

forward_list： 单向链表

右值引用

左值引用和右值引用的区别

左值引用： 可以取地址 + 赋值，定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

右值引用： 右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引 用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

注意：

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可
以取到该位置的地址。即：右值引用有左值的性质

int&& rr1 = 10;
rr1 = 20;
cout << &rr1 << endl;
1
2
3

左值引用与右值引用比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

const int& ra3 = 10;
1

右值引用总结：

3. 右值引用只能右值，不能引用左值。
4. 但是右值引用可以move以后的左值。

int&& r3 = std::move(a);
1

移动构造和移动赋值

左值引用的使用场景：

1. 做参数（减少拷贝，输出型参数）
2. 做返回值（减少拷贝，引用返回修改对象（operator[]））

缺点：

左值引用返回不能返回局部变量，那么局部对象返回时就会发生拷贝。即使编译器发生了优化也会发生至少一次的拷贝

右值引用就是用来解决上面的缺点的：

通过右值引用传参的方式，重载构造函数。对于自定义类型的右值，可以看作是将亡值，可以直接换取它的资源。

移动构造：

// 移动构造
string(string&& s)
	:_str(nullptr)
	,_size(0)
	,_capacity(0)
{
	cout << "string(string&& s) -- 移动语义" << endl;
	swap(s);
}
1
2
3
4
5
6
7
8
9

移动赋值：

// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;
	swap(s);
	return *this;
}
1
2
3
4
5
6
7

所以在使用的时候不能随便对左值进行move，move之后左值会变成右值，资源也可以被转移。

所有的容器都增加了移动构造和移动赋值，同时插入接口也有右值版本。

模板的万能引用和完美转发

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }

// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}
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

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。

完美转发：让引用类型保持原有属性

template<typename T>
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));
}
1
2
3
4
5

类的新功能

新的类的成员函数

原来C++类中，有6个默认成员函数：

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载

在C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

• 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

• 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

• 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

强制生成和删除默认成员函数

强制生成：

Person(Person&& p) = default;
1

删除：

Person(const Person& p) = delete;
1

可变参数模板

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
1
2
3
4
5

通过递归函数展开参数包：

// 递归终止函数
template <class T>
void ShowList(const T& t)
{
	cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
	cout << value <<" ";
	ShowList(args...);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

逗号表达式展开参数包：

template <class T>
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12

emplace 和 insert

emplace 使用的是将可变参数模板。

// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
// 是先构造，再移动构造，其实也还好。
std::list< std::pair<int, bit::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort"});
1
2
3
4
5
6
7

对比insert接口最大的效率优化在与直接构造和减少拷贝构造。

lambda表达式

lambda表达式语法：

lambda表达式书写格式：
[capture-list] (parameters) mutable -> return-type { statement}
1
2

• [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量 性。使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

lambda表达式实际上是一个匿名函数，可以通过auto自动推到类型存储起来。

捕捉列表声明：

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

• [var]：表示值传递方式捕捉变量var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)

注意：

1. 父作用域指包含lambda函数的语句块，指的是该函数的函数栈帧，全局变量同样能捕捉
2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
   比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
3. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
4. 在块作用域以外的lambda函数捕捉列表必须为空。
5. lambda表达式之间不能相互赋值，即使看起来类型相同，但是可以赋值给同类型的函数指针

void (*PF)();
int main()
{
	auto f1 = []{cout << "hello world" << endl; };
	auto f2 = []{cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
	//f1 = f2; // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数对象与lambda表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

lambda表达式在底层实现上按照函数对象的方式实现。即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

在底层lambda是lambda_uuid形式。

包装器

将不同的类型按照同意的形式进行包装，简化代码。

function包装器

使用方法：

// 函数名
std::function<double(double)> func1 = f;

// 函数对象
std::function<double(double)> func2 = Functor();

// lamber表达式
std::function<double(double)> func3 = [](double d)->double{ return d /
4; };
1
2
3
4
5
6
7
8
9

bind

std::bind 函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
1
2
3
4
5
6
7

调用bind的一般形式：

auto newCallable = bind(callable,arg_list);
1

1. 其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数
2. arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。这些占位符在placeholders的命名空间中。

调整参数顺序：

bind 可以调整函数的参数顺序：

int sub(int a, int b)
{
	return a - b;
}

auto func = bind(sub, placeholders::_2, placeholders::_1);
// func = b - a;
1
2
3
4
5
6
7

调整参数个数：

调用成员函数时需要指定成员函数，可以通过bind绑定成员函数。

Sub s;
// 绑定成员函数
std::function<int(int, int)> func = std::bind(&Sub::sub, s,
placeholders::_1, placeholders::_2);
// func = s->sub;
1
2
3
4
5