【C++语言】C++11新特性（1）

一、统一的列表初始化

1.1 {} 初始化

        在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{
     int _x;
     int _y;
};

int main()
{
     int array1[] = { 1, 2, 3, 4, 5 };
     int array2[5] = { 0 };
     Point p = { 1, 2 };
     return 0;
}

       为了实现统一性，C++11扩大了使用大括号扩起的列表（初始化列表）的使用范围，使其可用于所有的内置类型和用户自定义类型，使用初始化列表时，可以添加等号（=），也可以不用添加（不推荐）。

struct Point
{
     int _x;
     int _y;
};

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 };

       我们在创建对象时也可以使用列表初始化方式调用构造函数初始化，实例代码如下：

class Date
{
public:
     Date(int year, int month, int day)
         :_year(year)
         ,_month(month)
         ,_day(day)
     {
         cout << "Date(int year, int month, int day)" << endl;
     }
private:
     int _year;
     int _month;
     int _day;
};
int main()
{
     Date d1(2022, 1, 1); // 以前的写法

     // C++11支持的列表初始化，这里会调用构造函数初始化
     Date d2{ 2022, 1, 2 };
     Date d3 = { 2022, 1, 3 };
     return 0;
}

1.2 std::initializer_list

1.2.1 std::initializer_list的背景和基础

       initializer_list 是一种C++11新的类型特性，它允许我们以统一的方式初始化对象。它是一个代表数组的轻量级包装器，通常用于构造函数和函数参数中，以允许传递一个初始化元素列表。

       initializer_list是C++11提供的新类型，定义在头文件中。 std::initializer_list 是定义在<initializer_list> 头文件中的一个模板类。它可以用于接收花括号初始化列表（例如 {1, 2, 3}）作为参数。

1.2.2 std::initializer_list的工作原理

       当使用花括号初始化语法时，编译器会生成一个 std::initializer_list 对象。这个对象实际上包含了两个指针，一个指向数组的开始，另一个指向数组的结束。因此，它的大小相对固定，通常是两个指针的大小。 

       C++11扩大了初始化列表的适用范围，使其可用于所有内置类型和用户定义的类型。无论是初始化对象还是某些时候为对象赋新值，都可以使用这样一组由花括号括起来的初始值了。使用初始化列表时，可添加=，也可不添加。

1.2.3 使用 initializer_list 的优缺点

优点：

1. 统一初始化语法：使用 initializer_list，可以为不同的容器和对象类型提供统一的初始化语法
2. 简化构造函数重载：可以用一个接受 initializer_list 参数的构造函数替代多个重载版本
3. 支持范围 for 循环：initializer_list 支持基于范围的 for 循环，使得遍历元素变得非常简洁

缺点：

1. 只读：initializer_list 中的元素是只读的，你不能修改其中的元素
2. 性能考虑：使用 initializer_list 可能涉及数组的复制，尤其是在传递给构造函数或函数时
3. 生命周期：initializer_list 引用的元素数组的生命周期与 initializer_list 对象的生命周期相同，这可能导致悬垂引用的风险

二、声明

       C++11提供了多种简化声明的方式，尤其是在使用模版时。

2.1 auto

       auto在范围for中使用比较广泛，以及一些场景中变量的类型比较长时使用。在C++98中，auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型（auto没有什么作用）。

       在C++11中，将auto原本的用法进行废除，使其实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。但是不要用auto定义函数返回值。

// 范围for中使用
for(auto k : a)

// 变量类型比较长，进行简化代码
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();

2.2 decltype

2.2.1 decltype的介绍

       关键字decltype将变量的类型声明为表达式指定的类型。使用场景的代码如下：（我们只需要定义变量，变量类型是什么交给编译器就好了）

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
// 如果我们不知道变量的类型，可以使用decltype自动推导
    decltype(t1 * t2) ret;
    cout << typeid(ret).name() << endl;
}

2.2.2 aut和decltype的区别 

       虽然auto和decltype都能让编译器帮我们去分析表达式所属的类型，但是两者还是有一些区别。auto和decltype的主要区别有三个方面：

1. auto类型说明符用编译器计算变量的初始值来推断其类型，而decltype虽然也让编译器分析表达式并得到它的类型，但是不实际计算表达式的值。
2. 编译器推断出来的auto类型有时候和初始值的类型并不完全一样，编译器会适当地改变结果类型使其更符合初始化规则。例如，auto一般会忽略顶层const，而把底层const保留下来。与之相反，decltype会保留变量的顶层const。
3. 与auto不同，decltype的结果类型与表达式形式密切相关，如果变量名加上了一对括号，则得到的类型与不加括号时会有不同。如果decltype使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，则编译器将推断得到引用类型。

2.3 nullptr

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

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

三、左值引用和右值引用

3.1 左值引用和右值引用的介绍

       传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

3.1.1 什么是左值？什么是左值引用？

       左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左 值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;

// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;

3.1.2 什么是右值？什么是右值引用？

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

// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);

// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);

       需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可 以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地 址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇， 这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

3.2 左值引用与右值引用比较

3.2.1 左值引用总结

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

// 左值引用只能引用左值，不能引用右值。
int a = 10;
int& ra1 = a;   // ra为a的别名
//int& ra2 = 10;   // 编译失败，因为10是右值

// const左值引用既可引用左值，也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;

3.2.2 右值引用总结

1. 右值引用只能右值，不能引用左值
2. 但是右值引用可以move以后的左值

// 右值引用只能右值，不能引用左值。
int&& r1 = 10;
 
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
int&& r2 = a;
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);

3.3 右值引用使用场景和意义

我们先来看一看左值引用的使用场景和短板：

左值引用的使用场景

        做参数和做返回值都可以提高效率。

左值引用的短板

       当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回， 只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回， 传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

右值引用和移动语义解决上述问题：

       在string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不 用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

// 移动构造
string(string&& s)
    :_str(nullptr)
    ,_size(0)
    ,_capacity(0)
{
    cout << "string(string&& s) -- 移动语义" << endl;
    swap(s);
}

       当我们写好右值引用的构造函数，再运行上面to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用 了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。

不仅仅有移动构造，还有移动赋值：

       在string类中增加移动赋值函数，再去调用bit::to_string(1234)，不过这次是to_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

// 移动赋值
string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}

       这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。