新特性主要包括两个方面：语法改进、标准库扩充
- 语法改进
（1）统一的初始化方法
#include<iostream>
using namespace std;
class Test
{
public:
int value;
Test(int num)
{
value = num;
}
Test(const Test& test)
{
value = test.value;
}
};
- 成员变量默认初始化
优点：构造类对象时，不需要构造函数初始化成员变量。
#include<iostream>
using namespace std;
class A
{
public:
int m = 1234;
int n;
};
int main()
{
A a;
cout << a.m << endl;
return 0;
}
- auto 关键字
编译器自动判定变量类型。
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> vec1{ 1,2,3,4 };
//vector<int>::iterator ite = vec1.begin();
auto ite = vec1.begin();
cout << *(ite ) << endl;
cout << *ite << endl;
return 0;
}
- decltype 求表达式的类型
decltype 和auto功能相似，编译时自动类型推导。
（1）为什么要有delctype
auto并不适用于任何类型推导，或是使用不便，亦或是无法使用。两者区别：
auto varname = value; decltype(exp) varname = value;
varname 表示变量名，value 表示赋给变量的值，exp 表示一个表达式。
auto 根据"="右边的初始值 value 推导出变量的类型，而 decltype 根据 exp 表达式推导出变量的类型，跟"="右边的 value 没有关系。所以auto要求变量必须初始化，而decltype不需要。
//b 被推导成了 int
int a = 0; decltype(a) b = 1;
//x 被推导成了 double
decltype(10.8) x = 5.5;
//y 被推导成了 double
decltype(x 100) y;
- 智能指针shared_ptr
和 unique_ptr、weak_ptr 不同之处在于，多个 shared_ptr 智能指针可以共同使用同一块堆内存.
#include <iostream>
#include <memory>
using namespace std;
int main()
{ //构建 2 个智能指针
shared_ptr<int> p1(new int(10));
shared_ptr<int> p2(p1);
//输出 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;
}
运行结果：
- 空指针nullptr（原来的NULL）
nullptr 是 nullptr_t 类型的右值常量，专用于初始化空类型指针。也就是说，nullptr 仅为 nullptr_t 类型的一个实例化对象。同时，nullptr可以被隐式转化位任意类型。
int * x1 = nullptr;
char * x2 = nullptr;
double * x3 = nullptr;
显然，然后类型指针变量都可以用 nullptr 进行初始化。同时，将指针变量初始化为nullptr，能够解决NULL遗留的问题。
#include<iostream>
using namespace std;
void isNull(void* ptr)
{
cout << "void* ptr" << endl;
}
void isNull(int m)
{
cout << "int m" << endl;
}
int main()
{
isNull(NULL);
isNull(nullptr);
return 0;
}
运行结果：
- for遍历
for(元素：对象)
{
//循环体
}
#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
int main()
{
//普通数组遍历
char arr[] = { "www.Abin.com" };
for (auto e : arr)
{
cout << e ;
}
cout << endl;
//字符串遍历
string str1 = { "www.Abin.com" };
for (auto e : str1)
{
cout << e;
}
cout << endl;
//vector 容器遍历
vector<string> vec = {"我","喜欢","豆包"};
for (auto e : vec)
{
cout << e ;
}
cout << endl;
//map 遍历
map<int, string> hash_map = { {1,"我"},{2,"喜欢"},{3,"豆包"} };
for (auto e : hash_map)
{
cout << e.first << "\t" << e.second << endl;
}
return 0;
}
- 右值引用和move语义
（1）右值引用
C 98/03标准中，引用使用的是“&”。这引用方式有一个缺陷，即正常情况下，只能操作 C 中的左值，无法对右值添加引用。
int num = 1103;
int &b = num; //正确
int &c = 1103; //错误
上面这种引用，在C 98/03 标准中的引用又称为左值引用。虽然不支持为右值建立非常量左值引用，但允许使用常量左值引用操作右值。
int num = 1103;
const int &b = num;
const int &c = 1103;
右值往往是没有名称的，因此要使用它只能借助引用的方式。这样就会产生一个问题，在实际开发中，我们可能需要对右值进行修改（实现移动语义时就需要），显然上面左值引用的方式是行不通的。
C 11 标准新引入了另一种引用方式，称为右值引用，用 "&&" 表示
int num = 1103;
//int && a = num; //右值引用不能初始化为左值
int && a = 1103;
与常量左值引用不同的是，右值引用还可以对右值进行修改。
int && a = 1103;
a = 100;
cout << a << endl;
/* 程序运行结果：
100
*/
C 语法上是支持定义常量右值引用的
const int&& a = 10;//编译器不会报错
这种定义出来的右值引用并无实际意义。一方面，右值引用主要用于移动语义和完美转发，其中前者需要有修改右值的权限；其次，常量右值引用的作用就是引用一个不可修改的右值，这项工作完全可以交给常量左值引用完成。
- move语义
可以将某个左值强制转化为右值。
move( arg ) //其中，arg 表示指定的左值对象。该函数会返回 arg 对象的右值形式。
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
string str = "Hello";
vector<string> v;
//调用常规的拷贝构造函数，新建字符数组，拷贝数据
v.push_back(str);
cout << "After copy, str is:" << str << endl;
//调用移动构造函数，掏空str，掏空后，最好不要使用str
v.push_back(move(str));
cout << "After move, str is :" << str << endl;
cout << "The contents of the vector are :" << v[0]
<< "\t" << v[1] << endl;
return 0;
}
运行结果：
- 哈希表（无序容器）
（1）哈希表的两个特点：
1、哈希表内部存储的键值对是无序的，各键值对的存储位置取决于该键值对中的键。
2、与关联式容器相比，哈希表擅长通过指定键查找对应的值（平均时间复杂度为 O(1)），但对于使用迭代器遍历容器中存储的元素，无序容器的执行效率则不如关联式容器。
（2）无序容器：unordered_map、unordered_multimap、unordered_set 、unordered_multiset。
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;
int main()
{
//创建并初始化一个 unordered_map 容器，其存储的 <string,string> 类型的键值对
unordered_map<string, string> myMap
{
{"C语言教程","www.123.com"},
{"C 语言教程","www.234.com"},
{"Python语言教程","www.345.com"}
};
//查找指定键对应的值，效率比关联式容器高
string str = myMap.at("C语言教程");
cout << "str = " << str << endl;
//使用迭代器遍历哈希容器，效率不如关联式容器
for (auto iter = myMap.begin(); iter != myMap.end(); iter)
{
//pair 类型键值对分为 2 部分
cout << iter->first << " " << iter->second << endl;
}
return 0;
}
运行结果：
- 正则表达式
本质上就是一个字符串，这些字符串具有特殊含义，可以用于查找、替换符合规则的字符串。常用符号
- Lambda表达式
没有名称的函数。格式
[外部变量访问方式说明符] (参数) mutable noexcept/throw() -> 返回值类型 { 函数体; };
（1）[外部变量访问方式说明符] 。[ ] 方括号用于向编译器表明当前是一个 lambda 表达式，其不能被省略。在方括号内部，可以注明当前 lambda 函数的函数体中可以使用哪些“外部变量”。
（2）(参数) 。与普通函数的定义一样，lambda 匿名函数也可以接收外部传递的多个参数。和普通函数不同的是，如果不需要传递参数，可以连同 () 小括号一起省略；
（3）mutable。此关键字可以省略，如果使用则之前的 () 小括号将不能省略（参数个数可以为 0）。默认情况下，对于以值传递方式引入的外部变量，不允许在 lambda 表达式内部修改它们的值（可以理解为这部分变量都是 const 常量）。而如果想修改它们，就必须使用 mutable 关键字。
（4）noexcept/throw()。可以省略，如果使用，在之前的 () 小括号将不能省略（参数个数可以为 0）。默认情况下，lambda 函数的函数体中可以抛出任何类型的异常。标注 noexcept 关键字，则表示函数体内不会抛出任何异常；使用 throw() 可以指定 lambda 函数内部可以抛出的异常类型。
（5）->返回类型。匿名函数的返回类型。如果 lambda 函数体内只有一个 return 语句，或者该函数返回 void，则编译器可以自行推断出返回值类型，此情况下可以直接省略"-> 返回值类型"。
（6）与普通函数相同。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int num[4] = { 9,7,8,6 };
//对 num数组中的元素进行排序
sort(num, num 4, [=](int x, int y) -> bool { return x < y; });
for (int n : num) {
cout << n << " ";
}
return 0;
}
运行结果：
