C++新特性

新特性主要包括两个方面：语法改进、标准库扩充

• 语法改进

（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/ target=_blank class=infotextkey>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;
}

运行结果：