C++11---(2)

一、新增容器

1.1、array

头文件#include <array>

array特点

• array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
• STL 还提供有可动态扩展或收缩存储空间的 vector 容器

array优点

• 使用 array 保存在栈内存中，相比堆内存中的 vector，我们就能够灵活的访问这里面的元素，从而获得更高的性能；同时正式由于其堆内存存储的特性，有些时候我们还需要自己负责释放这些资源。
• 使用array能够让代码变得更加现代，且封装了一些操作函数，同时还能够友好的使用标准库中的容器算法等等，比如 sort。
• array 会在编译时创建一个固定大小的数组，array 不能够被隐式的转换成指针，使用 std::array 很简单，只需指定其类型和大小即可

1.2、forward_list

头文件#include<forward_list>

forward_list特点

• forward_list只提供钱箱迭代器，因此不支持反向迭代器，比如rbegin()等成员函数。
• forward_list不提供size()成员函数。
• forward_list没有指向最末元素的锚点，因此不提供back()、push_back()和pop_back()。
• forward_list不提供随机访问，这一点跟list相同插入和删除元素不会造成“指向至其他元素”的指针，引用和迭代器失效。

成员函数

1.3、unordered系列

unordered系列在我的上几篇文章有分享，这里就不老生常谈了。

unordered_map和unordered_set-CSDN博客

二、****右值引用和移动语义

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们

之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

2.1、什么是左值，什么是左值引用

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋

值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左

值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
// 以下的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;
    return 0;
}

左值：
  1、可以取地址
  2、一般情况下可以修改（const修饰时不能修改）

2.2、什么是右值，什么是右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引

用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能

取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{
    double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
    10;
    x + y;
    fmin(x, y);
// 以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    10 = 1;
    x + y = 1;
    fmin(x, y) = 1;
    return 0;
}

注：1、右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。

2、move：当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件<utility>中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

2.3、左值引用和右值引用比较

**左值引用总结： **

1. 左值引用只能引用左值，不能引用右值。

2. 但是const左值引用既可引用左值，也可引用右值。

int main()
{
    // 左值引用只能引用左值，不能引用右值。
    int a = 10;
    int& ra1 = a;   // ra为a的别名
    //int& ra2 = 10;   // 编译失败，因为10是右值
    // const左值引用既可引用左值，也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    return 0;
}

**右值引用总结： **

1. 右值引用只能右值，不能引用左值。

2. 但是右值引用可以move以后的左值。

int a = 10;
int b = 20;
//不能引用左值
//int&& rr1 = a;
int&& rr2 = 10;
int&& rr3 = move(a);//强制转换为右值引用

2.4、**右值引用使用场景和意义 **

到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

void fun1(bit::string s)
{}
void fun2(bit::string& s)
{}
int main()
{
    bit::string s("1234");
    //fun1(s);
    //fun2(s);//左值引用提高了效率，不存在拷贝临时对象的问题

    //可以使用左值引用返回，这个对象还在
    s += 'a';
    //不能使用左值引用返回，这个就是左值引用的一个短板
    //函数返回对象出了作用域就不在了，就不能用左值引用返回（因为返回的是本身地址，栈帧已销毁）
    //所以会存在拷贝问题
    lyl::string ret = lyl::to_string(1234);
    return 0;
}

**左值引用的短板： **

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回,

只能传值返回。例如：lyl::string to_string(int value)函数中可以看到，这里只能使用传值返回，

传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

C++11移动语义的提出：将一个对象中资源移动到另一个对象中的方式。

str在按照值返回时，必须创建一个临时对象，临时对象创建好之后，str就被销毁了，str是一个将亡值，C++11认为其为右值，在用str构造临时对象时，就会采用移动构造，即将str中资源转移到临时对象中。而临时对象也是右值，因此在用临时对象构造s3时，也采用移动构造，将临时对象中资源转移到ret中，整个过程，只需要创建一块堆内存即可，既省了空间，又大大提高程序运行的效率。

1、这个时候我们应该如何来进行优化呢，这个时候就需要用到右值引用了。

我们再对右值加深这里我们仿照拷贝赋值，让他于拷贝形成一个对比，再写一个移动赋值

这里我们多一层理解，右值分为两类：

1**.纯的右值**，如10；x+y；

2**.临时创建的对象，将要销毁的返回值**。

** 优化的点在哪里呢？**

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

在string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不

用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

再运行上面to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用

了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。

// 移动赋值
string& operator=(string&& s) {
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this; }
int main()
{
 Self::string ret1;
 ret1 = Self::to_string(1234);
 return 0; 
}

// 运行结果：
string(string&& s) -- 移动语义
string& operator=(string&& s) -- 移动语义

这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象

接收，编译器就没办法优化了。bit::to_string函数中会先用str生成构造生成一个临时对象，但是

我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时

对象做为bit::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。

STL中的容器都是增加了移动构造和移动赋值:

cplusplus.com/reference/string/string/string/

cplusplus.com/reference/vector/vector/vector/

2.5、右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但是有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件<utility>中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
 return ((typename remove_reference<_Ty>::type&&)_Arg);
}
int main()
{
 lyl::string s1("hello world");
 // 这里s1是左值，调用的是拷贝构造
 lyl::string s2(s1);
 // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
 // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
 // 资源被转移给了s3，s1被置空了。
 lyl::string s3(std::move(s1));
 return 0;
}

总结：

右值引用出来以后，并不是直接使用右值引用去减少拷贝，提高效率。而是支持深拷贝的类，提供移动构造和移动赋值，这时这些类的对象进行传值返回或者是参数为右值时，则可以用移动构造和移动赋值，转移资源，避免深拷贝，提高效率。

三、完美转发

3.1、什么是完美转发

模板中的&& 万能引用

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
std::forward 完美转发在传参的过程中保留对象原生类型属性
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; 
}

运行结果：

    右值引用

    左值引用

    右值引用

    const 左值引用

    const 右值引用

std::forward 完美转发在传参的过程中保留对象原生类型属性

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力。
引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。
我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

3.2、完美转发使用场景：

这里我们以链表为例：

template<class T>
struct ListNode
{
    ListNode* _next = nullptr;
    ListNode* _prev = nullptr;
    T _data;
};
template<class T>
class List
{
     typedef ListNode<T> Node;
public:
     List()
     {
         _head = new Node;
         _head->_next = _head;
         _head->_prev = _head;
     }
 void PushBack(T&& x)
 {
     //Insert(_head, x);
     Insert(_head, std::forward<T>(x));
 }
 void PushFront(T&& x)
 {
     //Insert(_head->_next, x);
     Insert(_head->_next, std::forward<T>(x));
 }
 void Insert(Node* pos, T&& x)
 {
     Node* prev = pos->_prev;
     Node* newnode = new Node;
     newnode->_data = std::forward<T>(x); // 关键位置
     // prev newnode pos
     prev->_next = newnode;
     newnode->_prev = prev;
     newnode->_next = pos;
     pos->_prev = newnode;
 }
 void Insert(Node* pos, const T& x)
 {
     Node* prev = pos->_prev;
     Node* newnode = new Node;
     newnode->_data = x; // 关键位置
     // prev newnode pos
     prev->_next = newnode;
     newnode->_prev = prev;
     newnode->_next = pos;
     pos->_prev = newnode;
 }
private:
     Node* _head;
};

int main()
{
    List<Self::string> lt;
    Self::string s1("1111");
    lt.PushBack(s1);
 
    lt.PushBack("1111");
    lt.PushFront("2222");
 
 
    list<std::string> lt;
    
    std::string s1("1111");
     //这里调用的是拷贝构造
    lt.push_back(s1);
    
    // 下面调用都是移动构造
    lt.push_back("2222");
    lt.push_back(std::string("2222"));
    lt.push_back(std::move(s1));
 
    return 0;
}

四、新增类功能

4.1、默认成员函数

八个默认成员函数：

在C++11之前，一个类中有如下六个默认成员函数：

• 构造函数。
• 析构函数。
• 拷贝构造函数。
• 拷贝赋值函数。
• 取地址重载函数。
• const取地址重载函数

其中前四个成员函数最重要，后面两个成员函数一般不会用到，这里“默认”的意思就是你不写编译器会自动生成。在C++11标准中又增加了两个默认成员函数，分别是移动构造和移动赋值重载函数。

默认移动构造和移动赋值的生成条件：

C++11中新增的移动构造函数和移动赋值函数的生成条件如下：

• 移动构造函数的生成条件：没有自己实现移动构造函数，并且没有自己实现析构函数、拷贝构造函数和拷贝赋值函数。
• 移动赋值重载函数的生成条件：没有自己实现移动赋值重载函数，并且没有自己实现析构函数、拷贝构造函数和拷贝赋值函数。

特别注意： 如果我们自己实现了移动构造或者移动赋值，就算没有实现拷贝构造和拷贝赋值，编译器也不会生成默认的拷贝构造和拷贝赋值。

默认生成的移动构造和移动赋值会做什么？

• 默认生成的移动构造函数：对于内置类型的成员会完成值拷贝（浅拷贝），对于自定义类型的成员，如果该成员实现了移动构造就调用它的移动构造，否则就调用它的拷贝构造。
• 默认生成的移动赋值重载函数：对于内置类型的成员会完成值拷贝（浅拷贝），对于自定义类型的成员，如果该成员实现了移动赋值就调用它的移动赋值，否则就调用它的拷贝赋值。

4.2、类成员变量初始化

默认生成的构造函数，对于自定义类型的成员会调用其构造函数进行初始化，但并不会对内置类型的成员进行处理。于是C++11支持非静态成员变量在声明时进行初始化赋值，默认生成的构造函数会使用这些缺省值对成员进行初始化。比如

class Person
{
public:
    //...
private:
    //非静态成员变量，可以在成员声明时给缺省值
    cl::string _name = "张三"; //姓名
    int _age = 20;             //年龄
    static int _n; //静态成员变量不能给缺省值
};

注意： 这里不是初始化，而是给声明的成员变量一个缺省值。

4.3、强制生成默认函数的关键字default

C++11可以让我们更好的控制要使用的默认成员函数，假设在某些情况下我们需要使用某个默认成员函数，但是因为某些原因导致无法生成这个默认成员函数，这时可以使用default关键字强制生成某个默认成员函数。

例如，下面的Person类中实现了拷贝构造函数

class Person
{
public:
    //拷贝构造函数
    Person(const Person& p)
        :_name(p._name)
        , _age(p._age)
    {}
private:
    cl::string _name; //姓名
    int _age;         //年龄
};

这时如下代码就无法编译成功了，因为Person类中编写了拷贝构造函数，导致无法生成默认的构造函数，因为默认构造函数生成的条件是没有编写任意类型的构造函数，包括拷贝构造函数。

int main()
{
    Person s; //没有合适的默认构造函数可用

    return 0;
}

这时我们就可以使用default关键字强制生成默认的构造函数，如下：

class Person
{
public:
    Person() = default; //强制生成默认构造函数

    //拷贝构造函数
    Person(const Person& p)
        :_name(p._name)
        , _age(p._age)
    {}
private:
    cl::string _name; //姓名
    int _age;         //年龄
};

说明一下： 默认成员函数都可以用default关键字强制生成，包括移动构造和移动赋值。

4.4、禁止生成默认函数的关键字delete

当我们想要限制某些默认函数生成时，可以通过如下两种方式：

• 在C++98中，可以将该函数设置成私有，并且只用声明不用定义，这样当外部调用该函数时就会报错。
• 在C++11中，可以在该函数声明后面加上=delete，表示让编译器不生成该函数的默认版本，我们将=delete修饰的函数称为删除函数。

例如，要让一个类不能被拷贝，可以用=delete修饰将该类的拷贝构造和拷贝赋值。

class CopyBan
{
public:
    CopyBan()
    {}
private:
    CopyBan(const CopyBan&) = delete;
    CopyBan& operator=(const CopyBan&) = delete;
};

说明一下： 被=delete修饰的函数可以设置为公有，也可以设置为私有，效果都一样。