C++11新特性
前言1.统一初始化方法2.成员变量默认初始化3.auto关键字4.decltype 求表达式的类型5.智能指针 shared_ptr6. 空指针 nullptr（原来NULL）7. 基于范围的for循环8. 右值引用和move语义9.move9. 无序容器（哈希表）10. 正则表达式11. Lambda匿名函数
🌈欢迎来到C++基础专栏 🙋🏾♀️作者介绍：前PLA队员 目前是一名普通本科大三的软件工程专业学生 🌏IP坐标：湖北武汉 🍉 目前技术栈：C/C++、Linux系统编程、计算机网络、数据结构、Mysql、Python 🍇 博客介绍：通过分享学习过程，加深知识点的掌握，也希望通过平台能认识更多同僚，如果觉得文章有帮助，请您动动发财手点点赞，本人水平有限，有不足之处欢迎大家扶正~ 🍓 最后送大家一句话共勉：知不足而奋进，望远山而前行。 ————————————————
前言
C++新特性主要包括包含语法改进和标准库扩充两个方面，主要包括以下11点：
语法的改进 （1）统一的初始化方法 （2）成员变量默认初始化 （3）auto关键字 用于定义变量，编译器可以自动判断的类型（前提：定义一个变量时对其进行 初始化） （4）decltype 求表达式的类型 （5）智能指针 shared_ptr （6）空指针 nullptr（原来NULL） （7）基于范围的for循环 （8）右值引用和move语义 让程序员有意识减少进行深拷贝操作标准库扩充（往STL里新加进一些模板类，比较好用） （9）无序容器（哈希表） 用法和功能同map一模一样，区别在于哈希表的效率更高 （10）正则表达式 可以认为正则表达式实质上是一个字符串，该字符串描述了一种特定模式的字 符串 （11）Lambda表达式
1.统一初始化方法
C++98/03 可以使用初始化列表（initializer list）进行初始化：
int i_arr[3] = { 1, 2, 3 };
long l_arr[] = { 1, 3, 2, 4 };
struct A
{
int x;
int y;
} a = { 1, 2 };
但是这种初始化方式的适用性非常狭窄，只有上面提到的这两种数据类型可以使用初始化列表。在 C++11 中，初始化列表的适用性被大大增加了。它现在可以用于任何类型对象的初始化，实例如下：
class Foo
{
public:
Foo(int) {}
private:
Foo(const Foo &);
};
int main(void)
{
Foo a1(123);
Foo a2 = 123; //error: 'Foo::Foo(const Foo &)' is private
Foo a3 = { 123 };
Foo a4 { 123 };
int a5 = { 3 };
int a6 { 3 };
return 0;
}
在上例中，a3、a4 使用了新的初始化方式来初始化对象，效果如同 a1 的直接初始化。a5、a6则是基本数据类型的列表初始化方式。可以看到，它们的形式都是统一的。这里需要注意的是，a3 虽然使用了等于号，但它仍然是列表初始化，因此，私有的拷贝构造并不会影响到它。a4 和a6 的写法，是 C++98/03 所不具备的。在 C++11 中，可以直接在变量名后面跟上初始化列表，来进行对象的初始化
2.成员变量默认初始化
好处：构建一个类的对象不需要用构造函数初始化成员变量。
//程序实例
#include
using namespace std;
class B
{
public:
int m = 1234; //成员变量有一个初始值
int n;
};
int main()
{
B b;
cout << b.m << endl;
return 0;
}
3.auto关键字
用于定义变量，编译器可以自动判断的类型（前提：定义一个变量时对其进行初始化）。
//程序实例
#include
using namespace std;
int main(){
vector< vector
vector< vector
return 0;
}
可以看出来，定义迭代器 i 的时候，类型书写比较冗长，容易出错。然而有了 auto 类型推导，我们大可不必这样，只写一个 auto 即可。
4.decltype 求表达式的类型
decltype 是 C++11 新增的一个关键字，它和 auto 的功能一样，都用来在编译时期进行自动类型推导。 (1)为什么要有decltype 因为 auto 并不适用于所有的自动类型推导场景，在某些特殊情况下 auto 用起来非常不方便，甚至压根无法使用，所以 decltype 关键字也被引入到 C++11 中。 auto 和 decltype 关键字都可以自动推导出变量的类型，但它们的用法是有区别的：
auto varname = value;
decltype(exp) varname = value;
其中，varname 表示变量名，value 表示赋给变量的值，exp 表示一个表达式。 auto 根据"=“右边的初始值 value 推导出变量的类型，而 decltype 根据 exp 表达式推导出变量的类型，跟”="右边的 value 没有关系。 另外，auto 要求变量必须初始化，而 decltype 不要求。这很容易理解，auto 是根据变量的初始值来推导出变量类型的，如果不初始化，变量的类型也就无法推导了。decltype 可以写成下面的形式：
decltype(exp) varname;
代码示例
// decltype 用法举例
int a = 0;
decltype(a) b = 1; //b 被推导成了 int
decltype(10.8) x = 5.5; //x 被推导成了 double
decltype(x + 100) y; //y 被推导成了 double
5.智能指针 shared_ptr
和 unique_ptr、weak_ptr 不同之处在于，多个 shared_ptr 智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个 shared_ptr 指针放弃了堆内存的“使用权”（引用计数减 1），也不会影响其他指向同一堆内存的 shared_ptr 指针 （只有引用计数为 0 时，堆内存才会被自动释放）。
#include
#include
using namespace std;
int main()
{
//构建 2 个智能指针
std::shared_ptr
std::shared_ptr
//输出 p2 指向的数据
cout << *p2 << endl;
p1.reset();//引用计数减 1,p1为空指针
if (p1) {
cout << "p1 不为空" << endl;
}
else {
cout << "p1 为空" << endl;
}
//以上操作，并不会影响 p2
cout << *p2 << endl;
//判断当前和 p2 同指向的智能指针有多少个
cout << p2.use_count() << endl;
return 0;
}
/*
程序运行结果：
10
p1 为空
10
1
*/
6. 空指针 nullptr（原来NULL）
nullptr 是 nullptr_t 类型的右值常量，专用于初始化空类型指针。nullptr_t 是 C++11 新增加的数据类型，可称为“指针空值类型”。也就是说，nullpter 仅是该类型的一个实例对象（已经定义好，可以直接使用），如果需要我们完全定义出多个同 nullptr 完全一样的实例对象。值得一提的是，nullptr 可以被隐式转换成任意的指针类型。例如：
int * a1 = nullptr;
char * a2 = nullptr;
double * a3 = nullptr;
显然，不同类型的指针变量都可以使用 nullptr 来初始化，编译器分别将 nullptr 隐式转换成int、char 以及 double* 指针类型。另外，通过将指针初始化为 nullptr，可以很好地解决 NULL遗留的问题，比如
#include
using namespace std;
void isnull(void *c){
cout << "void*c" << endl;
}
void isnull(int n){
cout << "int n" << endl;
}
int main() {
isnull(NULL);
isnull(nullptr);
return 0;
}
/*
程序运行结果：
int n
void*c
*/
7. 基于范围的for循环
如果要用 for 循环语句遍历一个数组或者容器，只能套用如下结构：
for(表达式 1; 表达式 2; 表达式 3){
//循环体
}
代码示例
//程序实例
#include
#include
#include
using namespace std;
int main() {
char arc[] = "www.123.com";
int i;
//for循环遍历普通数组
for (i = 0; i < strlen(arc); i++) {
cout << arc[i];
}
cout << endl;
vector
vector
//for循环遍历 vector 容器
for (iter = myvector.begin(); iter != myvector.end(); ++iter) {
cout << *iter;
}
return 0;
}
/*
程序运行结果：
www.123.com
www
*/
8. 右值引用和move语义
右值引用 C++98/03 标准中就有引用，使用 “&” 表示。但此种引用方式有一个缺陷，即正常情况下只能操作 C++ 中的左值，无法对右值添加引用。举个例子：
int num = 10;
int &b = num; //正确
int &c = 10; //错误
如上所示，编译器允许我们为 num 左值建立一个引用，但不可以为 10 这个右值建立引用。因此，C++98/03 标准中的引用又称为左值引用。 注意，虽然 C++98/03 标准不支持为右值建立非常量左值引用，但允许使用常量左值引用操作右值。也就是说，常量左值引用既可以操作左值，也可以操作右值，例如：
int num = 10;
const int &b = num;
const int &c = 10;
我们知道，右值往往是没有名称的，因此要使用它只能借助引用的方式。这就产生一个问题，实际开发中我们可能需要对右值进行修改（实现移动语义时就需要），显然左值引用的方式是行不通的。 为此，C++11 标准新引入了另一种引用方式，称为右值引用，用 “&&” 表示。 需要注意的，和声明左值引用一样，右值引用也必须立即进行初始化操作，且只能使用右值进行初始化，比如：
int num = 10;
//int && a = num; //右值引用不能初始化为左值
int && a = 10;
和常量左值引用不同的是，右值引用还可以对右值进行修改。例如：
int && a = 10;
a = 100;
cout << a << endl;
/* 程序运行结果：
100
*/
另外值得一提的是，C++ 语法上是支持定义常量右值引用的，例如：
const int&& a = 10;//编译器不会报错
但这种定义出来的右值引用并无实际用处。一方面，右值引用主要用于移动语义和完美转发，其中前者需要有修改右值的权限；其次，常量右值引用的作用就是引用一个不可修改的值，这项工作完全可以交给常量左值引用完成。
9.move
本意为 “移动”，但该函数并不能移动任何数据，它的功能很简单，就是将某个左值 强制转化为右值。基于 move() 函数特殊的功能，其常用于实现移动语义。move() 函数的用法也很简单，其语法格式如下：
move( arg ) //其中，arg 表示指定的左值对象。该函数会返回 arg 对象的右值形式。
//程序实例
#include
using namespace std;
class first {
public:
first() :num(new int(0)) {
cout << "construct!" << endl;
}
//移动构造函数
first(first &&d) :num(d.num) {
d.num = NULL;
cout << "first move construct!" << endl;
}
public: //这里应该是 private，使用 public 是为了更方便说明问题
int *num;
};
class second {
public:
second() :fir() {}
//用 first 类的移动构造函数初始化 fir
second(second && sec) :fir(move(sec.fir)) {
cout << "second move construct" << endl;
}
public: //这里也应该是 private，使用 public 是为了更方便说明问题
first fir;
};
int main() {
second oth; second oth2 = move(oth);
//cout << *oth.fir.num << endl; //程序报运行时错误
return 0;
}
/*
程序运行结果：
construct!
first move construct!
second move construct
*/
9. 无序容器（哈希表）
用法和功能同map一模一样，区别在于哈希表的效率更高。 (1) 无序容器具有以下 2 个特点： a. 无序容器内部存储的键值对是无序的，各键值对的存储位置取决于该键值对中的键， b. 和关联式容器相比，无序容器擅长通过指定键查找对应的值（平均时间复杂度为 O(1)）；但对于使用迭代器遍历容器中存储的元素，无序容器的执行效率则不如关联式容器。 (2) 和关联式容器一样，无序容器只是一类容器的统称，其包含有 4 个具体容器，分别为 unordered_map、unordered_multimap、unordered_set 以及 unordered_multiset。功能如下表：
程序实例
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化一个 unordered_map 容器，其存储的
std::unordered_map
{"教程1","www.123.com"},
{"教程2","www.234.com"},
{"教程3","www.345.com"} };
//查找指定键对应的值，效率比关联式容器高
string str = my_uMap.at("C语言教程");
cout << "str = " << str << endl;
//使用迭代器遍历哈希容器，效率不如关联式容器
for (auto iter = my_uMap.begin(); iter != my_uMap.end(); ++iter)
{
//pair 类型键值对分为 2 部分
cout << iter->first << " " << iter->second << endl;
}
return 0;
}
/*
程序运行结果：
教程1 www.123.com
教程2 www.234.com
教程3 www.345.com
*/
10. 正则表达式
可以认为正则表达式实质上是一个字符串，该字符串描述了一种特定模式的字符串。常用符号的意义如下：
11. Lambda匿名函数
所谓匿名函数，简单地理解就是没有名称的函数，又常被称为 lambda 函数或者 lambda 表达 式。 （1）定义 lambda 匿名函数很简单，可以套用如下的语法格式： [外部变量访问方式说明符] (参数) mutable noexcept/throw() -> 返回值类型 { 函数体; }; 其中各部分的含义分别为： a. [外部变量方位方式说明符] [ ] 方括号用于向编译器表明当前是一个 lambda 表达式，其不能被省略。在方括号内部，可以注明当前 lambda 函数的函数体中可以使用哪些“外部变量”。 所谓外部变量，指的是和当前 lambda 表达式位于同一作用域内的所有局部变量。 b. (参数) 和普通函数的定义一样，lambda 匿名函数也可以接收外部传递的多个参数。和普通函数不同的是，如果不需要传递参数，可以连同 () 小括号一起省略； c. mutable 此关键字可以省略，如果使用则之前的 () 小括号将不能省略（参数个数可以为 0）。默认情况 下，对于以值传递方式引入的外部变量，不允许在 lambda 表达式内部修改它们的值（可以理解为这部分变量都是 const 常量）。而如果想修改它们，就必须使用 mutable 关键字。 注意:对于以值传递方式引入的外部变量，lambda 表达式修改的是拷贝的那一份，并不会修改 真正的外部变量； d. noexcept/throw() 可以省略，如果使用，在之前的 () 小括号将不能省略（参数个数可以为 0）。默认情况下，lambda 函数的函数体中可以抛出任何类型的异常。而标注 noexcept 关键字，则表示函数体内不 会抛出任何异常；使用 throw() 可以指定 lambda 函数内部可以抛出的异常类型。 e. -> 返回值类型 指明 lambda 匿名函数的返回值类型。值得一提的是，如果 lambda 函数体内只有一个 return语句，或者该函数返回 void，则编译器可以自行推断出返回值类型，此情况下可以直接省略"-> 返回值类型"。 f. 函数体 和普通函数一样，lambda 匿名函数包含的内部代码都放置在函数体中。该函数体内除了可以使用指定传递进来的参数之外，还可以使用指定的外部变量以及全局范围内的所有全局变量。 （2）程序实例
#include
#include
using namespace std;
int main()
{
int num[4] = {4, 2, 3, 1};
//对 a 数组中的元素进行排序
sort(num, num+4, [=](int x, int y) -> bool{ return x < y; } );
for(int n : num){
cout << n << " ";
}
return 0;
}
/* 程序运行结果：
1 2 3 4
*/