0. 引言
C++11简介：
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于
C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中
约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，
C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更
强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。
那么C++11在原有基础上做出了哪些更新呢？
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 main()
{int x1 = 1;//使用列表初始化数据时可以加 ‘=’ 也可以不加//单参数和多参数都能使用列表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 };return 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；
}创建对象时也可以使用列表初始化方式调用构造函数初始化:
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); // old style// C++11支持的列表初始化，这里会调用构造函数初始化Date d2{ 2022, 1, 2 };Date d3 = { 2022, 1, 3 };return 0;
}2. std::initializer_list初始化
std::initializer_list 是一个模板类，允许构造函数接受一个元素列表参数，以 {}的方式提供。这使得构造对象时可以用一个值列表进行初始化：
#include <initializer_list>
#include <vector>std::vector<int> vec = {1, 2, 3, 4}; // 使用 initializer_list
它和{}列表的关系也很密切：
int main()
{// the type of il is an initializer_listauto il = { 10, 20, 30 };cout << typeid(il).name() << endl;return 0;
}std::initializer_list使得类似与vector的容器进行多元素的初始化时更加方便，不仅如此，在STL库中，vector还重载了：
vector& operator= (initializer_list<value_type> il);
使得我们可以使用{}来赋值。
initializer_list的使用：
int main()
{vector<int> v = { 1,2,3,4 };list<int> lt = { 1,2 };// 这里{"sort", "排序"}会先初始化构造一个pair对象map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };// 使用大括号对容器赋值v = {10, 20, 30};return 0;
}模拟vector中initializer_list初始化和赋值：
template<class T>
class vector {
public:typedef T* iterator;//initializer_list初始化vector(initializer_list<T> l){_start = new T[l.size()];_finish = _start + l.size();_endofstorage = _start + l.size();iterator vit = _start;typename initializer_list<T>::iterator lit = l.begin();//initializer_list内部实现了迭代器while (lit != l.end()){*vit++ = *lit++;}//for (auto e : l)// *vit++ = e;}//initializer_list赋值
vector<T>& operator=(initializer_list<T> l) {vector<T> tmp(l);std::swap(_start, tmp._start);std::swap(_finish, tmp._finish);std::swap(_endofstorage, tmp._endofstorage);return *this;
}
private:iterator _start;iterator _finish;iterator _endofstorage;
};3. 类型
3.1 auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初
始化值的类型。
int main()
{int i = 10;auto p = &i;auto pf = strcpy;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//map<string, string>::iterator it = dict.begin();auto it = dict.begin();return 0;
}auto的使用使得许多含有模板参数的类型书写时更加简洁方便。
3.2 decltype
关键字decltype将变量的类型声明为表达式指定的类型：
// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret;cout << typeid(ret).name() << endl;
}
int main()
{const int x = 1;double y = 2.2;decltype(x * y) ret; // ret的类型是doubledecltype(&x) p; // p的类型是int*cout << typeid(ret).name() << endl;cout << typeid(p).name() << endl;F(1, 'a');return 0;
}3.3 nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
4. 范围for
C++11 引入了范围for循环（Range-based for loop），简化了对容器和数组的遍历。它提供了更简洁和安全的遍历方式，避免手动维护迭代器或索引变量。以下是它的基本使用方法和详细示例：
#include <iostream>int main() {int arr[] = {1, 2, 3, 4, 5};for (int x : arr) {std::cout << x << " ";}// 输出：1 2 3 4 5std::vector<int> vec = {1, 2, 3, 4, 5};for (auto& x : vec) {x *= 2; // 将每个元素乘以2}for (auto x : vec) {std::cout << x << " ";}// 输出：2 4 6 8 10 return 0;
}
甚至自己实现的容器只要实现了begin(),end()以及迭代器++的接口，也可以使用范围for。
5. 右值引用和移动语义
5.1 左右值引用的概念
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，但无论左值引用还是右值引用，都是给对象取别名。
在了解右值引用，首先要了解左值引用，了解左右值的概念。
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时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;
}右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
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;
}值得一提的特性：右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。（了解即可）
int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;rr2 = 5.5; // 报错return 0;
}左值引用和右值引用对比：
左值引用：
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以后的左值。
（move也是C++11新增的标准库函数，作用是将一个对象“显式地”转换为右值引用。它本质上不会“移动”任何数据，而是告知编译器可以将该对象的资源进行“转移”而不是“拷贝”。）
int main()
{// 右值引用只能右值，不能引用左值。int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;int&& r2 = a;// 右值引用可以引用move以后的左值int&& r3 = std::move(a);return 0;
}5.2 右值引用的应用
前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？
左值引用的短板：
namespace kia
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}// 移动构造string(string&& s):_str(nullptr),_size(0),_capacity(0){cout << "string(string&& s) -- 移动语义" << endl;swap(s);}// 移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动语义" << endl;swap(s);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}
private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};
} 当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，
只能传值返回。例如：kia::string to_string(int value)函数中可以看到，这里只能使用传值返回，
传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
右值引用和移动语义：
移动构造：
可以看到，上面的临时对象用完就释放了，却还要用临时对象拷贝生成最终的目标，很浪费空间，更好的办法是直接把临时对象的资格给目标，反正它也是将亡值（“将亡值”是 C++11 中定义的一种特殊右值，通常用于移动语义中，它表示即将被销毁的对象资源。）。
运用右值引用和移动语义就可以优化这种没有必要的拷贝：
右值引用带来了移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
// 移动构造
string(string&& s):_str(nullptr),_size(0),_capacity(0)
{cout << "string(string&& s) -- 移动语义" << endl;//交换右值的资源swap(s);
}
int main()
{string ret2 = to_string(-1234);return 0;
}此时不再调用拷贝构造，而是调用移动构造，移动构造中没有申请新的空间资源，效率更高，省去了没有必要的深拷贝。此时再经过编译器的优化，就一次拷贝构造都没有，而是直接用函数内的变量去移动构造目标了。
移动赋值：
// 移动赋值
string& operator=(string&& s)
{cout << "string& operator=(string&& s) -- 移动语义" << endl;swap(s);return *this;
}
int main()
{kia::string ret1;ret1 = kia::to_string(1234);return 0;
}
// 运行结果：
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义同理，移动赋值可以提高右值给变量的赋值效率，可以直接夺取右值的资源来减少空间开支，提高赋值效率。
结合move（）的使用：
当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{// forward _Arg as movablereturn ((typename remove_reference<_Ty>::type&&)_Arg);
}int main()
{kia::string s1("hello world");// 这里s1是左值，调用的是拷贝构造kia::string s2(s1);// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的// 资源被转移给了s3，s1被置空了。kia::string s3(std::move(s1));return 0;
}所以说并非是对于右值才使用移动语义，在特殊场景下，也可根据需要通过move把左值转化为右值进行资源的转移。
6. 万能引用和完美转发
模板中的&& 万能引用：
void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
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;
}上述代码运行结果：
这是因为左右值在传入函数内变为形参后，全都会退化为左值。
为了使左右值在万能引用后，能保持其左右值的属性，就有了完美转发。
std::forward 完美转发在传参的过程中保留对象原生类型属性：
void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{Fun(std::forward<T>(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;
}此时就可以根据左右值引用正确的进行调用了
完美转发实际中的使用场景：
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 posprev->_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 posprev->_next = newnode;newnode->_prev = prev;newnode->_next = pos;pos->_prev = newnode;}
private:Node* _head;
};
int main()
{List<kia::string> lt;lt.PushBack("1111");lt.PushFront("2222");return 0;
}使用完美转发可以帮助我们实现容器中的移动语义。
7. 类
7.1 成员函数
原来C++类中，有6个默认成员函数：
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载
C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
1. 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任
意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类
型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，
如果实现了就调用移动构造，没有实现就调用拷贝构造。
2. 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中
的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内
置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋
值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造
完全类似)
3. 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
可以看到，默认生成的移动构造函数和移动赋值运算符重载条件比起之前的默认成员函数是更加苛刻的。
强制生成默认函数的关键字default：
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p):_name(p._name),_age(p._age){}Person(Person&& p) = default;
private:kia::string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p) = delete;
private:kia::string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}7.2 继承多态
C++11中增加了final和override关键字。
final：用于禁止类继承或函数进一步重写。final关键字主要用于禁止继承或防止虚函数被进一步重写。它可以应用于类或虚函数中：
用于类：当一个类被声明为 final 时，该类不能被继承。
class Base final { }; // 这是一个无法被继承的类class Derived : public Base { }; // 错误！无法从 final 类继承
用于虚函数：当一个虚函数被声明为 final 时，派生类不能重写该函数。
class Base {
public:virtual void func() final; // 该函数不能在派生类中重写
};class Derived : public Base {void func() override; // 错误！func 被声明为 final，不能重写
};
override 关键字用于显示地指明一个虚函数是在派生类中重写基类的虚函数。它并不改变程序的行为，但有助于增强代码的安全性和可读性：
- 当使用
override时，编译器会检查基类中是否存在具有相同签名的虚函数，如果没有，则会产生编译错误。 override主要帮助避免函数签名拼写错误或不一致的问题。
class Base {
public:virtual void func(int) { } // 基类中的虚函数
};class Derived : public Base {
public:void func(int) override { } // 正确，func 的参数与基类一致void func(double) override { } // 错误！基类中没有匹配的虚函数
};
在某些情况下，可以将 final 和 override 一起使用，表示一个虚函数在被重写的同时，不允许进一步重写：
class Base {
public:virtual void func() { }
};class Derived : public Base {
public:void func() override final { } // 重写基类函数，并禁止再进一步重写
};class FurtherDerived : public Derived {
public:void func() override; // 错误！func 已被 final 修饰，无法再重写
};
final 和 override 增强了代码的可读性和安全性，帮助开发者更好地管理类继承关系和虚函数重写。
![C语言[求x的y次方]](https://img-blog.csdnimg.cn/8370269965df4d349ceafda5fd39b945.png)
