它不错更便捷地遍历容器中的元素
C++11是指C++谈话在2011年发布的范例，也称为C++11范例或C++0x。它引入了一系列新特质和创新，旨在提高代码的可读性、可防卫性和效劳。
一、C++ 11新特质C++ 11 范例是C++98后的新范例，该范例在 C++ 98 的基础上修正了约 600 个 C++ 谈话中存在的颓势，同期添加了约 140 个新特质，这些更新使得 C++ 谈话盖头换面，这使得C++11更像是从C++98/03中助长出的一种新谈话，比拟与C++98，C++11能更好地用于系统开垦和库开垦，其语法愈加陋劣、认知和安全，不仅功能更庞大，而且能培植措施员的开垦效劳。
1.1列表启动化C++98中常使花括号{}来启动化数组，而C++11扩大了花括号括起的列表(启动化列表)的使用限度，使其可用于通盘的内置类型和用户自界说的类型，使用启动化列表时，可添加等号(=)，也可不添加。如：
int a={1};//内置类型vector<int> v={1，2，3，4，5};//范例容器list<string> lt{"hello"，"world"};//概略＝号int* arr = new int[5]={1，2，3，4，5};// 动态数组对象想要赞枚举表启动化，需给该类(模板类)添加一个带有initializer_list类型参数的构造函数即可。initializer_list是系统自界说的类模板，该类模板中主要有三个方法：begin()、end()迭代器以及赢得区间中元素个数的方法size()。如：
initializer_list<int> il{ 1，2，3，4，5 };vector<int> v(il);//范例容器class Vector{Vector(initializer_list<T> il){....}};//自界说类型添加一个构造函数1.2类型推导在类型未知或者类型书写复杂时，可能需要类型推导。
1）auto
C++11中，不错使用auto来把柄变量启动化抒发式类型推导变量的践诺类型，不错给措施的书写提供许多便捷。auto使用的前提是：必须要对auto声明的类型进行启动化，不然编译器无法推导出auto的践诺类型。常用于限度for和迭代器定名。
2）decltype
decltype是把柄抒发式的践诺类型推上演界说变量时所用的类型，如：
1.推演抒发式类型作为变量的界说类型：
int a = 1，b=2;// 用decltype推演a+b的践诺类型，作为界说c的类型decltype(a+b) c;
2.推演函数复返值的类型
int* f(int x){return &x;}int main(){// 如果莫得带参数，推导函数的类型cout << typeid(decltype(f)).name() << endl;// 如果带参数列表，推导的是函数复返值的类型，防止：此处只是推演，不会实践函数cout << typeid(decltype(f(1))).name() <<endl;return 0;}1.3final与override1）final
final:修饰虚函数，表示该虚函数不行再被袭取。例：
class A {public:virtual void func() final {}};class B :public A {public:virtual void func() {}//这里语法会出现格外};2）override
override: 检查派生类虚函数是否重写了基类某个虚函数，如果莫得重写编译报错。例：
class A {public:virtual void func() {}};class B : public A {public:virtual void func() override{}//派生类中重写基类的函数格外时，会报错，这里不会};1.4新加多容器C++11中加多了静态数组array、forward_list以及unordered系列
1）array
常用的用[]界说的齐是在栈上开辟的数组，array是在堆上开辟空间，它的基本用法和序列式容器差未几。
2）forward_list
与list不同，它使用的是单链表，天然这样从简了空间，但是进行操作时的效劳比list低。
3）unordered系列
有unordered_set和unprdered_map两种，和set和map比拟，它们的底层使用的是哈希桶，效劳比底层是红黑树的set和map高好多，多量情况下优先使用unordered系列的容器。
1.5默许成员函数限定在C++中对于空类编译器会生成一些默许的成员函数，比如：构造函数、拷贝构造函数、运算符重载、析构函数和&和const&的重载、出动构造、出动拷贝构造等函数。如果在类中显式界说了，编译器将不会再行生成默许版块。未必期这样的法律阐述可能被健忘，最常见的是声明了带参数的构造函数，必要时则需要界说不带参数的版块以实例化无参的对象。而且未必编译器会生成，未必又不生成，容易酿成繁芜，于是C++11让措施员不错限定是否需要编译器生成。
1）显式缺省函数
在C++11中，不错在默许函数界说或者声明时加上=default，从而显式的辅导编译器生成该函数的默许版块，用=default修饰的函数称为显式缺省函数。如：
class A{public:A(int a): _a(a){}//有参A() = default;//无参，由编译器生成private:int _a;};2）删除默许函数
如果能想要截至某些默许函数的生成，在C++98中，是该函数建设成private，况且不给界说，这样只消其他东说念主想要调用就会报错。在C++11中更陋劣，只需在该函数声明加上=delete即可，该语法辅导编译器不生成对应函数的默许版块，称=delete修饰的函数为删除函数。如：
class A{public:A(int a): _a(a){}A(const A&) = delete;//抑止编译器生成拷贝构造函数，调用时报错A& operator(const A&) = delete;//抑止编译器生成=运算符重载，调用时报错private:int _a;};1.6右值援用1）左值与右值一般情况下：
普通类型的变量，因为著名字，不错取地址，齐认为是左值。
const修饰的常量，不可修改，只读类型的，表面应该按照右值对待，但因为其不错取地址(如果只是
const类型常量的界说，编译器不给其开辟空间，如果对该常量取地址时，编译器才为其开辟空间)。C++11认为其是左值。
如果抒发式的运行终结是一个临时变量或者对象，如C谈话中的纯右值，比如：a+b（抒发式）， 100（常量），将一火值。比如：抒发式的中间终结、函数按照值的状貌进行复返。这些认为是右值。
如果抒发式运行终结或单个变量是一个援用则认为是左值。
2）援用与右值援用比较
普通援用只可援用左值，不行援用右值，const援用既可援用左值，也可援用右值。C++11中右值援用，状貌为类型名+&&(如：int &&)，比援用多加一个“&”：只可援用右值，一般情况不行胜利援用左值。如：
int main(){int a = 10; //a为左值，10为右值int& ra1 = a; // ra为a的笔名//int& ra2 = 10; // 编译失败，因为10是右值const int& ra3 = 10; //const援用右值const int& ra4 = a; //const援用左值int&& r1 = 10; //右值援用变量r1，编译器产生了一个临时变量，r1践诺援用的是临时变量r1 = 0; //r1就不错被修改了int&& r2 = a; // 编译失败，因为右值援用不行援用左值return 0;}3）出动语义
C++11提议了出动语义想法，即：将一个对象中资源出动到另一个对象中的状貌，比如：
String{String(String&& s): _str(s._str){s._str = nullptr;}private:char *_str；};这里构造函数中添加了一个函数，它的参数是右值援用，这里是将s中成员变量赋值到构造的对象中，然后再处理s，也便是说，将s中的资源更始到构造对象中，由构造对象处理。在应用出动语义时，出动构造函数的参数不行为const类型的右值援用，而且编译器为类默许生成一个出动构造，该出动构造为浅拷贝，因此当类中波及到资源经管时，用户必须显式界说我方的出动构造。
4） 右值援用援用左值
当需要用右值援用援用一个左值时，不错通过move函数将左值更始为右值。它的功能便是将一个左值强制更始为右值援用，然后竣事出动语义。如：
struct Person{string _name;string _sex;int _age;};int main(){Person p1 = { "张三"，"男"，18 };string&& name = move(p1._name);//用move将_name更始为左值return 0;}图片
不错看到name和p1._name的地址是一样的。
5）完好转发
看以下一段代码：
void Fun(int& x) { cout << "左值援用" << endl; }void Fun(int&& x) { cout << "右值援用" << endl; }void Fun(const int& x) { cout << "const左值援用" << 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 = 20;PerfectForward(b); // const左值援用PerfectForward(std::move(b)); // const右值援用return 0;}左值援用左值援用左值援用const左值援用const左值援用它的运行终结如上，通过终结不错看出，PerfectForward函数的参数为右值时，并莫得调用对应的参数为右值的函数，可见编译器将传入的参数类型齐更始成了左值，要想责罚这种问题，就需要用到C++11中的完好转发了。
完好转发是指在函数模板中，透澈依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。完好转发是决策函数总但愿将参数按照传递给转发函数的践诺类型转给决策函数，而不产生罕见的支拨，就好像转发者不存在一样。所谓完好：函数模板在向其他函数传递自体态参时，如果相应实参是左值，它就应该被转发为左值；如果相应实参是右值，它就应该被转发为右值。这样作念是为了保留在其他函数针对转发而来的参数的傍边值属性进行不同处理（比如参数为左值时实施拷贝语义；参数为右值时实施出动语义）。
C++11通过forward函数来竣事完好转发，将上头的PerfectForward函数中调用Fun的参数调动一下就不错责罚，具体如下：
template<typename T>void PerfectForward(T&& t) { Fun(std::forward<T>(t)); }右值援用左值援用右值援用const左值援用const右值援用这样就把柄参数类型调用相应的Fun函数。
6）右值援用作用
竣事出动语义(出动构造与出动赋值)
给中间临时变量取笔名
竣事完好转发
1.7lambda抒发式lambda抒发式践诺是一个匿名函数，它能简化代码。
1）书写状貌：
[capture-list] (parameters) mutable -> return-type { statement }lambda抒发式各部分阐明：
[capture-list] : 捕捉列表，该列表老是出面前lambda函数的脱手位置，编译器把柄[]来判断接下来的代码是否为lambda函数，捕捉列表或者捕捉高下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则不错连同()一说念概略
mutable：默许情况下，lambda函数老是一个const函数，mutable不错取消其常量性。使用该修饰符时，参数列表不可概略(即使参数为空)。
->returntype：复返值类型。用追踪复返类型体式声明函数的复返值类型，莫得复返值时此部分可概略。复返值类型明确情况下，也可概略，由编译器对复返类型进行推导。
{statement}：函数体。在该函数体内，除了不错使用其参数外，还不错使用通盘拿获到的变量。
防止： 在lambda函数界说中，参数列表和复返值类型齐是可选部分，而捕捉列表和函数体不错为空。
2）应用示例
int main(){// 最陋劣的lambda抒发式， 无深嗜深嗜[]{};// 概略参数列表和复返值类型，复返值类型由编译器推导为intint a = 10， b = 20;[=]{return a + b; };// 概略了复返值类型，无复返值类型auto fun1 = [&](int c){b = a + c; };fun1(20);cout<<a<<" "<<b<<endl;//a为10，b为30// 完整的lambda函数auto fun2 = [=， &b](int c)->int{return b += a+ c; };cout<<fun2(10)<<endl;//终结为50return 0;}3）拿获列表阐明
捕捉列表刻画了高下文中那些数据不错被lambda使用，以及使用的状貌传值如故传援用。
[var]：表示值传递状貌捕捉变量var
[=]：表示值传递状貌拿获通盘父作用域中的变量(包括this)
[&var]：表示援用传递捕捉变量var
[&]：表示援用传递捕捉通盘父作用域中的变量(包括this)
[this]：表示值传递状貌捕捉刻下的this指针
防止事项：
父作用域指包含lambda函数的语句块
语法上捕捉列表可由多个捕捉项构成，并以逗号分割。
比如：[=， &a， &b]：以援用传递的状貌捕捉变量a和b，值传递状貌捕捉其他通盘变量 [&，a， this]：值
传递状貌捕捉变量a和this，援用状貌捕捉其他变量 c. 捕捉列表不允许变量近似传递，不然就会导致编
译格外。 比如：[=， a]：=照旧以值传递状貌捕捉了通盘变量，捕捉a近似
在块作用域之外的lambda函数捕捉列表必须为空。
在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量齐
会导致编译报错。
lambda抒发式之间不行彼此赋值，即使看起来类型交流
4）函数对象
函数对象，又称为仿函数，即不错像函数一样使用的对象，便是在类中重载了operator()运算符的类对象，如库中的less仿函数：
template <class T> struct less : binary_function <T，T，bool> {bool operator() (const T& x， const T& y) const {return x<y;}};在调用仿函数时，不错用匿名对象调用，或者构建一个对象来调用，如：
int main(){int a = 10， b = 20;cout << "a<b?: "<<less<int>()(a， b) << endl;//匿名对象调用less<int> l;//创建对象l再调用cout << "a<b?: "<<l(a， b) << endl;return 0;}【著作福利】小编保举我方的Linux C++技巧交流群:【1106675687】整理了一些个东说念主以为比较好的学习竹帛、视频贵府分享在群文献里面，有需要的不错自行添加哦！！！前100名进群领取，罕见施助大厂口试题。图片
二、C++11经常考到的常识点2.1自动类型揣测（auto要害字）和限度-based for轮回区别？自动类型揣测（auto要害字）：在变量声明时使用auto要害字，编译器会把柄变量的启动化抒发式揣测出变量的类型。举例：
auto x = 10; // 揣测x为整数型auto str = "Hello"; // 揣测str为字符串型
这样不错简化代码，尤其对于复杂的类型称号或模板类型参数愈加便捷。
限度-based for轮回：用于遍历容器中的元素，不需要手动限定迭代器。举例：
std::vector<int> numbers = {1， 2， 3， 4， 5};for(auto num : numbers) {std::cout << num << " ";}2.2限度-based for轮回会交替将容器中的每个元素赋值给迭代变量num，使得遍历容器变得愈加简约和直不雅。C++11引入了限度-based for轮回（也称为foreach轮回），它不错更便捷地遍历容器中的元素。使用限度-based for轮回，不错自动将容器中的每个元素赋值给迭代变量，使得遍历容器变得愈加简约和直不雅。
举例，对于一个容器vector<int>，咱们不错使用限度-based for轮回来遍历它：
std::vector<int> numbers = {1， 2， 3， 4， 5};for (int num : numbers) {// 对每个元素进行操作std::cout << num << " ";}上述代码会交替将numbers中的每个元素赋值给迭代变量num，并输出该值。通过这种状貌，咱们不错便捷地对容器进行遍历操作。限度-based for轮回适用于援救迭代器或begin/end成员函数的多样容器类型。
2.3nullptr要害字，用于表示空指针吗？是的，nullptr是C++11引入的要害字，用于表示空指针。它不错作为常量null的更安全和直不雅的替代品，在措施中明确表示一个空指针。使用nullptr不错幸免在不同高下文中可能产生二义性的情况，况且或者提供更好的类型检查和类型推导。
2.4强制类型调动新法律阐述，如static_cast、dynamic_cast、const_cast和reinterpret_cast。强制类型调动是在C++顶用于将一个类型的值调动为另一种类型。底下是四种常见的强制类型调动状貌：
static_cast：主要用于基本数据类型之间的调动，以及具有袭取关系的指针或援用之间的调动。它在编译时进行类型检查，不提供运行时的检查。
dynamic_cast：主要用于类档次结构中，进行安全地向下转型（派生类到基类）和进取转型（基类到派生类）。它在运行时进行类型检查，如果无效则复返空指针（对指针）或抛出std::bad_cast异常（对援用）。
const_cast：主要用于去除const属性。通过const_cast不错将const对象调动为非const对象，况且还不错通过它修改蓝本被声明为const的变量。
reinterpret_cast：这是一种较初级别和危急性较高的调动状貌，它不错将任何指针或整数类型彼此调动。它不会实践任何特定的检查，只是陋劣地再行阐述给定值所占据内存位置的含义。
2.5Lambda抒发式，用于创建匿名函数。是的，Lambda抒发式用于创建匿名函数。它提供了一种简约的语法来界说并传递函数，昔日在需要使用函数作为参数或需要一个临时函数的场所使用。
Lambda抒发式的基本语法如下：
[拿获列表](参数列表) -> 复返类型 {函数体}其中，
拿获列表（Capture List）不错指定要在Lambda抒发式中探听的外部变量。
参数列表（Parameter List）界说了传递给Lambda函数的参数。
复返类型（Return Type）指定了Lambda函数的复返值类型。
函数体（Function Body）包含了践诺实践的代码。
举例，以下是一个使用Lambda抒发式创建匿名函数并传递给STL算法std::for_each的示例：
#include <iostream>#include <vector>#include <algorithm>int main() {std::vector<int> numbers = {1， 2， 3， 4， 5};// 使用Lambda抒发式打印每个元素std::for_each(numbers.begin()， numbers.end()， [](int num) {std::cout << num << " ";});return 0;}这个Lambda抒发式 [ ](int num) { std::cout << num << " "; }接受一个整数参数，并输出该数字。在上述示例中，咱们将其作为参数传递给std::for_each算法以打印每个元素。
2.6出动语义和右值援用（&&运算符），用于竣事高效的资源经管和幸免不必要的拷贝构造函数调用。出动语义和右值援用是C++11引入的特质，用于竣事高效的资源经管和幸免不必要的拷贝构造函数调用。
出动语义通过将资源的通盘权从一个对象更始到另一个对象来提高性能。在传统的拷贝操作中，会先进行深度复制，然后再放弃原始对象。而出动操作则是将原始对象的资源指针或情状信息更始到决策对象中，而不进行数据的复制。这样不错大大减少内存拷贝和数据处理支拨。
右值援用（&&运算符）是表示“具名值”的左值援用（&运算符）之外的一种新类型援用。它主要与出动语义集会使用，在函数参数、复返值和赋值等场景中施展作用。通过使用右值援用参数，不错显式地抒发出一个临时对象不错被出动或接纳其资源。
对于类筹谋者来说，合理利用出动语义和右值援用不错优化类的性能，并幸免不必要的资源拷贝。同期，C++范例库中也提供了一些援救出动语义的容器、智能指针等器用，进一步简化了资源经管。
2.7启动化列表，允许在对象启动化时使用大括号进行成员启动化。是的，启动化列表允许在对象启动化时使用大括号进行成员启动化。它不错在构造函数中使用，况且语法如下：
class MyClass {public:MyClass(int a， int b) : memberA(a)， memberB(b) {// 构造函数的其他操作}private:int memberA;int memberB;};在上头的例子中，memberA和memberB通过启动化列表进行启动化。这样不错幸免先创建对象再逐一赋值的罕见支拨，提高了效劳。同期，如果成员变量是常量或援用类型，则必须使用启动化列表进行启动化。
2.8类型笔名与using要害字，用于界说自界说类型笔名。是的，C++中不错使用typedef要害字或using要害字来界说自界说类型笔名。
使用typedef要害字：
typedef int myInt; // 将int类型界说为myInt类型的笔名typedef std::vector<int> IntVector; // 将std::vector<int>界说为IntVector类型的笔名
使用using要害字：
using myInt = int; // 将int类型界说为myInt类型的笔名using IntVector = std::vector<int>; // 将std::vector<int>界说为IntVector类型的笔名
不管使用typedef如故using，它们齐不错用于简化复杂的类型声明，提高代码可读性。
2.9线程援救库（std::thread），允许并发实践代码块。是的，std::thread是C++范例库中提供的线程援救库，它允许并发实践代码块。使用std::thread，你不错创建新的线程并在其中实践指定的函数或可调用对象。这样不错竣事多个任务同期实践，从而提高措施的性能和反馈性。
底下是一个陋劣示例：
#include <iostream>#include <thread>// 线程函数void printMessage() {std::cout << "Hello from thread!" << std::endl;}int main() {// 创建新线程，并在其中实践printMessage函数std::thread t(printMessage);// 干线程不时实践其他任务std::cout << "Hello from main thread!" << std::endl;// 恭候子线程完成t.join();return 0;}上述代码创建了一个新线程，并在该线程中实践printMessage函数。同期，干线程会打印"Hello from main thread!"。当子线程完成后，使用t.join()恭候子线程退出。
需要防止的是，在使用std::thread时需要正确经管资源和同步操作，幸免竞态条件和内存探听问题。
2.10合理使用智能指针（如std::shared_ptr和std::unique_ptr）来经管动态内存分派，幸免内存泄漏和吊挂指针问题。智能指针是一种庞大的器用，用于经管动态分派的内存，不错匡助咱们幸免内存泄漏和吊挂指针问题。
std::unique_ptr是一种独占通盘权的智能指针。它确保唯唯一个指针不错探听资源，并在不再需要时自动开释内存。它得当用于单个通盘者场景，举例领有一个对象或经管动态分派的数组。
std::shared_ptr是一种分享通盘权的智能指针。多个 shared_ptr不错分享对合并资源的通盘权，首页-达康安颜料有限公司况且会自动追踪援用计数。唯独当终末一个 shared_ptr开释资源时， 首页-达名兴服装有限公司内存才会被开释。这使得 std::shared_ptr至极适用于需要分享资源通盘权的场景。
使用智能指针不错灵验地经管动态内存， 安达市达亨服务器有限公司况且遏制易出现内存泄漏或吊挂指针问题。但要防止，在使用 std::unique_ptr时要幸免轮回援用，而在使用 std::shared_ptr时要探讨引起性能支拨和潜在的死锁风险。
三、C++11新特质追思3.1move semantics （出动语义）1）为什么需要出动语义
假定咱们先界说并启动化vector v1和v2，v1中有5个int，而v2为空， 然后实践 v2 = v1， 这会调用拷贝构造函数，会将v1的通盘元素拷贝至v2。
图片
一些情况下，这样的深拷贝是必要，但是未必期照实是低效的。就比如咱们有createVector这样的函数，它会复返一个vector对象。在c++11之前，这样的代码
std::vector<int> v2{};v2 = createVector();将会对createVector复返的临时对象进行拷贝，即会在堆上分派新的空间将临时对象的内容拷贝过来，进而重置v2的情状。但是咱们知说念这个临时对象是很快就会被析构的（它将鄙人一滑被析构），咱们透澈不错使v2“窃取”这个临时对象在堆上的内容。
就像底下这样，vector对象所有就存储了3个指针来经管通盘这个词数组，只消将指针拷贝过来再把temp对象的指针置为0就不错了。
图片
什么样的对象不错窃取呢？---那些人命值相当瞬息的对象，那些临时对象。这些对象不错绑定到右值援用上（这是C++11为了援救出动语义，新提议的一种援用类型），一朝察觉到一个援用是一个右值援用，那么编译器就不错胜利窃取它们的通盘物而不是拷贝它们（昔日的阐扬是：编译器倾向于弃取实践出动构造\赋值，而不是弃取拷贝构造\赋值）。
右值援用与左值援用的最大区别在于： 右值援用的人命周期更瞬息， 昔日右值援用的作用域只在一滑之内。
图片
左值援用不错用取地址记号 & 进行操作， 但是右值援用不不错，由于右值援用的人命周期相当短，是以也就意味着咱们不错“窃取”右值援用的通盘物。
如何窃取这些暂态对象？咱们不错界说出动构造\赋值函数。
2）出动构造\赋值函数
出动构造函数与出动语义一同被提议，C++11以后好多的stl容器添加了对应的出动构造\赋值函数。比如vector容器的operator=，在C++11后有两种典型的重载：
vector& operator=( const vector& other ); // 经典的拷贝赋值函数，实践深拷贝经由vector& operator=( vector&& other ); // c++11起，出动赋值函数，实践“浅拷贝”经由
第一种则是经典的拷贝赋值函数；而第二种则是出动赋值函数。C++11后，如果咱们再写这样的代码：
std::vector<int> v2{};v2 = createVector();编译器将识别到 = 右边是一个临时对象，将调用出动赋值函数将临时对象的元素“窃取”至v2中，提高了实践效劳。
类的出动构造函数何时自动生成如果措施员不声明（也不行记号为 =default 或者 =delete）5个特殊成员函数（拷贝构造、拷贝赋值、出动构造、出动赋值、析构函数）的任何一个，且类的每个非静态成员齐是可出动时，那么编译器会为这个class自动生成出动构造和出动赋值。反之，如果手动界说了，或者只是将拷贝构造函数记号为 =default，那么编译器就不会为这个class生成出动构造和赋值函数。
如何编写我方的出动构造函数？编写示范如下，其中与std::move联系的扣问见下一末节：
图片
因为int是基本类型，是以在启动化阶段不管你用毋庸std::move调动齐不会出错。但是对于字符串s来说就不一样了，如果咱们不加std::move就会出错，因为 即使出动构造函数接受右值援用，但是 w 在这个构造函数中是一个左值援用（因为它著名字w），是以 w.s 亦然一个左值援用，咱们要调用 std::move(w.s)将字符串调动为左值，不然咱们将会复制字符串而不是出动。右值援用的这个特质会在之后的内容中，引出“完好转发”这个话题。
另外，还需要将w.pi置为nullptr，为什么？因为右值援用所绑定的对象是行将腐化的，当它在被析构时，唯独将它所经管的指针置零，才不会将照旧被更始的数据删除，才不会酿成未界说行为。
3）std::move胜利从代码例子看move的作用：
图片
第一个赋值动作 v2 = v1 ，会调用vector的拷贝赋值函数，因为v1是一个左值；
第二个赋值动作中编译器识别到 = 号右边是一个临时对象，是以调用出动赋值操作符，这赶巧知足咱们的需求。
而第三个赋值操作，std::move，将v1这个左值援用调动为了右值援用(std::move只是是一个static_cast)，是以第三个赋值动作也会调用出动赋值函数。
请防止咱们调用了 std::move(v1)，它只是是对这个变量贴了一个标签，告诉编译器咱们之后不会用到v1了，是以践诺上std::move不会“出动”任何东西，它只是改变了变量的类型（从左值到右值），使得编译器弃取了出动赋值函数。着实或者体现“move”的，是类的出动构造\赋值函数。
如果使用了move作用后的变量会怎么样？不笃定，咱们不行对被move作用后的变量作念出假定，C++范例只是划定这些被出动的对象（Moved From Object）处在一个未知但灵验的情状（valid but unspecified state），这取决于函数编写者的具体竣事。
但同期C++范例也划定这些处于未知但灵验情状的被出动的对象或者：
被蹧蹋，即或者调用析构函数
被再行赋值
赋值、拷贝、出动给另一个对象
因此一个被出动的对象，咱们尽可能不要去操作它的指针类型成员，很可能酿成未界说行为，但如果咱们再行为这个被出动对象赋予了新的、灵验的值，那么咱们就不错再诓骗用它。
std::vector<int> v1{createVector();};std::vector<int> v2{std::move(v1)};// v1在被再行赋值之前，它处于未知情状，最佳不要去使用它v1 = createVector();doSomething(v1); // v1被再行赋值后，咱们又不错正常使用它了4）noexcept与出动语义
底下是《C++ Move Semantics The Complete Guide》一书中的例子：
class Person{private:std::string name;public:Person(const char* c_name):name{c_name} {}// 拷贝构造Person(const Person& other):name{other.name} {std::cout << name << " COPY constructed!" << std::endl;} // 出动构造Person(Person&& other):name{std::move(other.name)} {std::cout << name << " MOVE constructed!" << std::endl;}};为Person类界说了拷贝构造函数和出动构造函数，并在函数体中打印教导动作。
然后，不雅察Person类对象与vector联系的动作：(防止底下的例子的字符串齐很长，这是为了遏制微型字符串优化(SSO，具体竣事依赖于union的特质，共用capacity字段和微型字符串的存储空间)），即短小的字符串类将胜利在栈上保存内容，而非在堆开辟空间，栈上存放指向堆空间的指针；如果发生了SSO优化，那么出动操作并不比复制操作更快)
int main() {Person p1{"Wolfgang Amadeus Mozart"};Person p2{"Johann Sebastian Bach"};Person p3{"Ludwig van Beethoven"};std::cout << "\n push 3 ele in a vector whose capacity is 3 : \n";std::vector<Person> v1;v1.reserve(3);v1.push_back((std::move(p1)));v1.push_back((std::move(p2)));v1.push_back((std::move(p3)));std::cout << "\n push 4th ele in the vector， which will cause reallocation : \n";Person p4{"Poelea Selo Beajuhhdda"};v1.push_back(std::move(p4));}输出如下：
push 3 ele in a vector whose capacity is 3Wolfgang Amadeus Mozart MOVE constructed!Johann Sebastian Bach MOVE constructed!Ludwig van Beethoven MOVE constructed!push 4th ele in the vector， which will cause reallocationPoelea Selo Beajuhhdda MOVE constructed!Wolfgang Amadeus Mozart COPY constructed!Johann Sebastian Bach COPY constructed!Ludwig van Beethoven COPY constructed!
不错看到，在vector进行reallocation之前的通盘push_back齐使用了右值援用的版块，因为咱们对具名对象使用了std::move使其调动成了右值。
但是当vector发生reallocation后，元素却是被拷贝到新的空间中的，照理说应该使用出动更便捷才对，为什么编译器在这里使用了拷贝语义？
原因可能出在vector的push_back是“强异常安全保证”的函数：如果在vector的reallocation时间有异常抛出，C++范例库得保证将vector回滚到它之前的情状。
为了竣事这种事务特质，比较容易的作念法便是在重分派的经由中使用拷贝，如果有任何一个元素分派空间失败或者拷贝失败，那么只是把新创建的元素放弃然后开释空间就不错回滚到先前的情状了。
相对的，使用出动来竣事这种事务特质就比较辛勤了，试想在reallocation时间有异常抛出，此时新的空间的元素照旧“窃取”了就空间的元素，因此想要回退到先前的情状，放弃新元素是不够的，咱们还得将新元素移回旧空间中--问题来了，怎么保证这个出动操作不发生任何格外呢？
不错看到，使用出动语义难以保证这种事务特质，除非编译器知说念这个类的出动构造函数不会抛出任何异常，不然它会在vector的reallocation时间弃取拷贝元素，而不是出动元素。
而noexcept要害字就或者示知编译器：该方法不会抛出异常，如果咱们在Person的出动构造函数后加上noexcept要害字，编译器就会在vector的reallocation时间弃取出动构造函数。
Person(Person&& other) noexcept :name{std::move(other.name)} {std::cout << name << " MOVE constructed!" << std::endl;}践诺上，编译器自动生成的出动构造函数会检测：
基类的出动构造是否noexcept
类成员的出动构造是否noexcept
如果知足，则编译器自动生成的出动构造函数会自动加上noexcept要害字
Person(Person&& other) = default; // 使用编译器生成的出动构造函数
输出如下：
push 3 ele in a vector whose capacity is 3 : push 4th ele in the vector， which will cause reallocation :
莫得拷贝构造函数的输出教导，标明重分派阶段使用了出动构造函数，也阐明编译器为它我方生成的出动构造函数后加上了noexcept。
5）std::move 使用实例
来自CMU15445lab源码
// executor_factory.cpp // Create a new insert executorcase PlanType::Insert: {auto insert_plan = dynamic_cast<const InsertPlanNode *>(plan);auto child_executor =insert_plan->IsRawInsert() ? nullptr : ExecutorFactory::CreateExecutor(exec_ctx， insert_plan->GetChildPlan());return std::make_unique<InsertExecutor>(exec_ctx， insert_plan， std::move(child_executor)); // move了child_executor}InsertExecutor的构造函数应该这样写：
InsertExecutor::InsertExecutor(ExecutorContext *exec_ctx， const InsertPlanNode *plan，std::unique_ptr<AbstractExecutor> &&child_executor): AbstractExecutor(exec_ctx)， plan_(plan)， child_executor_(std::move(child_executor)) {如果把启动化列表中的std::move去掉，编译器报错如下：
Call to deleted constructor of 'std::unique_ptr<AbstractExecutor>'， uniqueptr的拷贝构造函数是被删除的，是以咱们不行用左值援用启动化一个uniqueptr，是以咱们必须调用std::move将child_executor变量先调动为右值援用，这也阐明了child_executor即使被绑定到一个右值援用上，它自身却是一个左值援用。
但是咱们调用构造函数的时期照实将左值调动成右值了不是吗？
std::make_unique<InsertExecutor>(exec_ctx， insert_plan， std::move(child_executor));
不错这样交融，在这一滑的作用域中，充电器 std::move(child_executor) 照实将左值调动成了右值，编译器笃定child_executor在这一滑以后将不会再被使用。但是参加到拷贝函数的作用域中，编译器又不行笃定该参数的人命周期了，因此在拷贝函数的作用域中如故将其看作左值类型。
一句话追思便是，右值变量在邻接的嵌套作用域中并不会传递"右值"这个属性，因此咱们有了下一章对“完好转发”的扣问。
3.2完好转发在《C++ Move Semantics The Complete Guide》一书中，它将完好转披发在了第三部分Move Semantics in Generic Code，也便是说完好转发是同期波及到出动语义和泛型编程的一个想法。
1）为什么需要完好转发
“转发”的含义是一个函数把我方的形参传递给另一个函数（即调用另一个函数），但是在引入右值后，这些转发可能需要破耗一些元气心灵：
比如现存3个版块的foo()函数：
class X{public:X() {a = 1;}int a ;};void foo(const X& x) {// 绑定通盘只读变量// do some read only jobcout << "foo(const X& x) called\n";} void foo(X& x) { // 绑定左值援用// do a lot of job， can modify x cout << "foo(X& x) called\n";} void foo(X&& x) { // 绑定右值援用// do a lot of job， can modify x， even can move x since x is rvalue referencescout << "foo(X&& x) called\n";// std::move(x) is valid!}假如要通过另一个函数callFoo调用foo函数，那么为了分离参数类型，callFoo也应该要写三个重载版块达成"完好转发"的效劳：
void callFoo(const X& x) {foo(x); // 调用void foo(const X&)}void callFoo(X& x) {foo(x);// 调用void foo(X&)}void callFoo(X&& x) {foo(std::move(x));// 调用void foo(X&&)， 防止std::move， x在callFoo函数域中是一个左值// 在调用foo前，需要将其更始为右值}防止第三个重载版块，在调用foo前必须对x进行std::move，因为“move semantics is not automatically passed through”（见上一章的源码实例）
防止到咱们编写三个callFoo函数，能否使用泛型只写一个函数模板？只怕很难。假定你只编写底下callFoo函数的泛型版块
template<typename T >void callFoo(T x) {foo(x);}在main函数中这样使用它：
int main() {const X const_x;X x;callFoo(const_x);callFoo(x);callFoo(X());}输出是：
foo(X& x) calledfoo(X& x) calledfoo(X& x) called
三个callFoo全部齐调用了foo(X& x) 函数，莫得竣事完好转发。原因与模板推导讨论，因为void callFoo(T x)表示值传递，因此参数永久被推导为X，不会有援用性，也不会保留const属性，详见《effective modern C++》条件1。
如果你想打个补丁：
void callFoo(T& x)void callFoo(T&& x)
g++编译器会报错Call to 'callFoo' is ambiguous。况且，即时哪种编译器能通过编译，这样的写法少量齐不"泛型"， 你齐写了这样多重载的泛型函数了，为什么还用泛型？而且，如果函数参数有2个，那么需要编写9个版块，如果参数有3个则要编写27个重载版块，不错想到，需要提供的重载版块数跟着泛型参数的加多呈现指数级增长。
因此C++11 引入了两种特殊的机制，以在泛型编程中达成上述的“完好转发”效劳:
全能援用
std::forward
具体代码如下：
template<typename T>void callFoo(T&& arg) { // 这是一个全能援用，而不是右值援用foo(std::forward<T>(arg)); // 使用std::forward保捏参数的类型：如果arg在传入callFoo时是左值，则让其保捏左值；不然将其更始为右值}只需要编写以上一个泛型版块的callFoo即可完成对foo函数参数的完好转发效劳！
2）全能援用和std::forward
template<typename T>void callFoo(T&& arg) // 右值援用？ 不，是全能援用
在泛型编程中，T&&看上去像是右值援用，但它其实是全能援用，它或者绑定通盘的对象（包括const、non-const，左值、右值），以下调用齐是正当的，而且，它们或者保捏参数的常量性和值的类型（左值\右值）。
X v;const X c;callFoo(v); // arg的型别 是 X&callFoo(c); // arg的型别 是 const X&callFoo(X{}); // arg的型别 是 X&&callFoo(std::move(v)); // arg的型别 是 X&&callFoo(std::move(c)); // arg的型别 是 const X&&空洞而言，如果调用函数时传递的参数类型是左值，那么全能援用就绑定到一个左值，如果传递的参数是右值，那么全能援用就绑定到一个右值。
防止 ：分离全能援用和右值援用（详见modern effective C++条件24）并不是形如 T&&的援用便是全能援用，T必须波及类型推导时，T&&才是全能援用，典型场景便是在泛型编程中的T&&。且即时在泛型编程场景下，const T&&并不是全能援用，它只可绑定 const X&&auto&& 亦然一个全能援用，它也波及型别推导一句话：全能援用必须波及型别推导其余或者绑定任何类型的援用则是const&， 但是它莫得保存参数是否是const的信息，而全能援用能保存参数是否为const的信息为什么还需要std::forward呢？这与全能援用或者“绑定任何类型的对象”的特质讨论：
右值援用只可绑定可出动的对象，因此函数编写者100%笃定他使用的函数参数或者被作用于std::move。void callFoo(X&& x) { //或者调用这个函数的参数一定亦然右值援用foo(std::move(x)); // 因此或者毫无胆怯的调用std::move将其再次更始为右值}
关联词全能援用或者绑定任何对象，因此函数编写者不行笃定他使用的参数是否在被std::move作用后是否保捏原来的援用类型（“原来的类型”指的是函数作用域外，用来传递给函数形参的对象的类型），要竣事完好转发不行使用std::move，只可使用std::forward。template<typename T> void callFoo(T&& arg) { // 这是一个全能援用，任何参数齐能调用这个函数1. foo(std::move(arg)); // 如果使用std::move，则无条件将参数更始为右值，这是分歧的！2. foo(std::forward<T>(arg));// 这样才合适，会先将arg更始为对应的类型，然后调用对应的函数版块}
std::forward的功能如下所述：
std::forward(arg)是一个有条件的std::move(arg)， 即
如果arg是一个右值援用，则std::forward(arg)将会等效为std::move(arg)
如果arg是一个左值援用，则std::forward(arg)将会等效为 arg
通过全能援用和std::forward，咱们就不错在泛型编程中竣事完好转发：
template<typename T>void callFoo(T&& arg) { // 这是一个全能援用，而不是右值援用foo(std::forward<T>(arg)); // 使用std::forward保捏参数的类型：如果arg在传入callFoo时是左值，则让其保捏左值；不然将其更始为右值}// 调用的函数foo有3个重载版块，见上末节X v;const X c;callFoo(v); // std::forward<T>(arg) => arg， 调用 foo(X&)callFoo(c); // std::forward<T>(arg) => arg， 调用 foo(const X&)callFoo(X{}); // std::forward<T>(arg) => std::move(arg)， 调用foo(X&&)callFoo(std::move(v)); // std::forward<T>(arg) => std::move(arg)， 调用foo(X&&)callFoo(std::move(c)); // std::forward<T>(arg) => std::move(arg)， 调用foo(cosnt X&)接下来，将文牍完好转发或者运行的旨趣。
3）援用折叠
援用折叠是完好转发或者起作用的底层机制，但是在交融援用折叠之前，需要再了解一些模板型别推导的常识。
因为这里主要波及完好转发，因此只扣问波及全能援用的函数模板型别推导。比如这样的函数声明：
template<typename T>void callFoo(T&& arg);
若以某个抒发式expr调用它：
callFoo(expr);
编译器会进行两处类型推导，一是推导T的型别，二是推导T&&的型别（即arg的型别）。
且由于函数参数使用的是全能援用，因此会对左值类型的expr有特殊处理方法。
①expr是右值的情景，编译器是这样对T进行型别推导的：
若expr有援用型别，则先将援用部分忽略
然后，对expr的型别和 T&& 进行模式匹配，来决定T的型别
比如callFoo(1)，此时expr为1，它是一个右值，它的类型为 int&&， 在与T&&进行模式匹配后，得到T的类型为int。终末天然地得到arg的型别为T&&，即arg是一个右值援用。
图片
②但如果expr是一个左值，编译器会将T推导为左值（至于为什么，我不是很了了，个东说念主倾向于将其阐述为范例的划定）。
然后会将T&&的型别也便是arg的型别推导为左值! 举例：
int x = 1;callFoo(x); //expr型别为 int&， T的型别为 int&， arg的型别亦然 int&
等等，T的型别被推导为int&， 那为什么arg的型别亦然int&， 不应该是int& && 吗？
这便是援用折叠施展作用的场所了，C++莫得“援用的援用”这样的型别。因此如果你脑补了一个类的型别出现了3个或3个以上&记号，那么就一定得把它们更始成左值或者右值，具体的法律阐述由C++范例如下划定：
图片
这里主要不雅察第二个法律阐述，该划定就决定了上例的arg的型别被推导为左值援用，从int& && 折叠为 int&。
作念个追思，当使用全能援用的模板参数时，编译器有一套特殊的类型推导法律阐述：
如果传递的参数是一个右值，T的推导终结就历害援用型别，arg的推导终结便是右值援用型别
如果传递的参数是一个左值，T的推导终结便是左值援用型别，又由于"援用折叠"这个划定，于是arg的推导终结亦然左值援用型别
个东说念主看来，虽说援用折叠是完好转发的底层机制，但这其实便是C++范例会的一系列划定，是从需求开赴的定制的一系列划定。
讨论模板类型推导的其余内容请参考《effecive modern C++》条件1。
4）std::forward原交融析
有了援用折叠的这个想法后，交融std::forward的旨趣也就不难了。
底下从《effecive modern C++》条件28种摘抄的代码片断，它展示了一种不透澈安妥C++范例的std::forward竣事，但用来交融旨趣照旧饱和：
template<typename T>T&& forward(typename remove_reference<T>::type& param){return static_cast<T&&>(param);}看到std::forward的底层竣事便是一个static_cast，于此同期全能援用与援用折叠在这里缄默起了很大的作用。底下，分别文牍使用左值和右值进行forward调用的参数推导经由。
仍然用上一节的例子进行阐明：
template<typename T>void callFoo(T&& arg){foo(std::forward<T>(arg)); }// 情况一，传递左值int x = 1;callFoo(x);// 情况二， 传递右值callFoo(1)①如果传递给callFoo的参数蓝本为左值援用的int类型，那么按照上一节的参数推导法律阐述，T将被推导为 int&，防止这里的类型推导指callFoo这个函数的类型推导，forward将不进行类型推导，因为在实践forwar调用时照旧指明了具体类型（尖括号中的T）。将int& 插入forward模板中得到底下的代码：
int& && forward(typename remove_reference<int&>::type& param) {return static_cast<int& &&>(param);}其中的remove_reference<int&>::type，看名字就不错知说念这便是将<>内的型别去掉援用部分后得到的型别。在这里便是int，终末加上末尾的&，那么param的型别就被推导为int&。
终末再加上援用折叠的法律阐述，咱们得到：
int& forward(int& param) {return static_cast<int&>(param) // static_cast 将参数更始为左值援用，践诺上没什么作用，因为param照旧是左值援用了}②如果传递给callFoo的参数蓝本为右值援用的int类型，T将被推导为int，它不是一个援用类型，将其插入forward模板得到：
int&& forward(int& param) {return staric_cast<int&&>(param); // static_cast 将左值援用类型的参数更始为右值援用}这里莫得发生援用折叠。
追思：
当传递参数为左值援用时，forward将复返左值援用
当传递参数为右值值援用时，forward将复返右值援用
这恰好便是完好转发需要的组件！
3.3智能指针1）总览
C++ 11 所有有4种智能指针， std::auto_ptr std::unique_ptr std::shared_ptr std::weak_ptr
std::auto_ptr 是个从C++98残留住来的特质，在C++17中，照旧被声明为depracated了
std::unique_ptr 借助右值援用使得出动操作成为可能，责罚了auto_ptr的问题
std::weak_ptr则不错用来责罚std::shared_ptr的轮回援用的问题。
2）std::auto_ptr
最初望望 auto_ptr， 了解咱们为什么C++弃用它，它有什么不及之处。
咱们把动态分派的堆内存的开释任务交给这些类，当这些类的人命周期收尾时会自动调用析构函数，析构函数经常有delete之类的操作开释这些动态分派的内存。这样的公正是，指针经管防卫对咱们酿成的心智包袱会大大减少。
咱们写一个Auto_Ptr类，模拟指针的操作，况且在析构函数中 对我方防卫的指针进行delete
template <typename T>class Auto_Ptr {public:Auto_Ptr(T* ptr) : ptr_(ptr){ }~Auto_Ptr() {delete ptr_;}// 重载底下两个运算符，使得类或者像指针一样运作T& operator*() {return *ptr_;}T* operator->() {return ptr_;}private:T* ptr_;};class A {public:A() {std::cout <<"class A construct!\n";}~A() {std::cout << "class A destroyed";}int attr_a = 2;};zint main() {Auto_Ptr<A> autp (new A());std::cout << autp->attr_a << std::endl;// autO的行为就像是一个指针std::cout << (*autp).attr_a << std::endl;return 0; // Auto_Ptr类自动delete，开释动态分派的内存}或者得到底下的输出信息 ：
class A construct!22class A destroyed
这样一个或者自动开释动态内存的类就与智能指针类的想想类似，但是Auto_ptr面前有两个问题
不行pass by value ， 不然，意味有两个以上的autp_ptr中的指针指向了合并块内存，这两个autp_ptr收尾人命周期时一定会调用析构函数，但不管以哪种礼貌调用析构函数，齐会在合并个指针上调用两次以上delete操作，segment fault！。咱们不错手动抑止Auto_Ptr的复制函数， 这样倒是不错责罚这个的问题。
但抑止Auto_Ptr的复制函数后，如何编写一个复返Auto_Ptr对象的函数？：Auto_Ptr generateResource() // delete了Auto_Ptr的复制构造函数后，不行这样写了{ Resource* r{ new Resource() }; return Auto_ptr1(r);// 编译器报错}
好，那咱们不删除复制函数，而是创新它： 复制函数不单是陋劣拷贝指针， 而是将指针的通盘权从源对象“更始”到决策对象
template <typename T>class Auto_Ptr {public:...Auto_Ptr( Auto_Ptr& source) {ptr_ = source.ptr_;source.ptr_ = nullptr;}Auto_Ptr& operator=(Auto_Ptr& source) {if (&source == this) {return *this;}delete ptr_;ptr_ = source.ptr_;source.ptr_ = nullptr; // 将源对象的指针进行deletereturn *this;}...bool isNull() const { return ptr_ == nullptr; }};至少咱们面前或者 对函数参数进行passby value 了， 但是咱们很容易又酿成探听野指针的格外，因为传统不雅念来看，值传递的语义便是“复制”，但是咱们纠正了复制函数，践诺上实践是“出动”。而且从函数的声明不错看到，咱们传入的是non-const参数，表示咱们要修改它，这和传统的拷贝函数大不交流！
void DoSomeThing(Auto_Ptr<A> s) { // pass by value 并进行相应操作std::cout << s->attr_a;}int main() {Auto_Ptr<A> res1 (new A());DoSomeThing(res1); // 按值传递，告捷。但是res1这个变量照旧被"出动"了std::cout << res1->attr_a <<std::endl; //再次使用res1，crash !}追思
autpptr是C++尝试“出动语义”的脱手，但是老是阐扬出将资源从一个object更始到另一个object的行为
autp_ptr的污点：
使用复制构造\赋值函数模拟出动语义，相当容易酿成野指针兴奋。也不行和范例库很好地一说念服务，比如一个存放auto_ptr的vector容器，对它使用std::sort函数，sort函数在某措施中会中式序列中的某一个并保存一个局部副本... value_type pivot_element = *mid_point; ...算法认为在这行代码实践完之后，pivot_element 和 *mid_point是交流的，但是因为auto_ptr的拷贝操作是对出动操作的师法，当实践完这行代码后，mid_point所指向的内存是不笃定的。终末算法正确性就受到了碎裂
auto_ptr中的析构函数老是使用delete ，是以它不行对动态分派的数组作念出正确的开释操作（而unique_ptr不错自界说deleter）
中枢问题 ：
如果咱们在想让对象在拷贝的时期或者被拷贝，出动的时期或者被更始限定权，那么就一切好办了。这便是为什么C++提议了“出动语义”（好家伙，C++11的新特质好多齐和出动语义联系）
C++11提议右值援用，很便捷地抒发了出动语义，以此带来了表示独占的、只可被出动而不行被拷贝的unique_ptr
3）std::unique_ptr
unique_ptr的大小与裸指针交流（如果不使用函数指针自界说删除器），这是智能指针中最常用的。
对于unique_ptr的大小，库函数使用了空基类优化的妙技，具体竣事状貌不错参考这篇著作C++11引进了出动语义，或者将object的出动或拷贝以更了了的状貌分离，也多出了两种特殊的成员函数， 出动构造和出动赋值。底下用新的成员函数纠正之前的Auto_Ptr。其实逻辑和之前竣事的拷贝函数是一样的，但这里的逻辑是出动逻辑，不应该放在拷贝函数中。
...// 参数是右值援用， 且非constAuto_Ptr( Auto_Ptr&& source) {ptr_ = source.ptr_;source.ptr_ = nullptr;}// 参数是右值援用，非constAuto_Ptr& operator=( Auto_Ptr&& source) {if (&source == this) {return *this;}delete ptr_;ptr_ = source.ptr_;source.ptr_ = nullptr;return *this;}...参数是non-const的右值援用，因为是右值援用，是以毋庸加const 属性， “右值”表示这个值的人命周期很瞬息，无所谓咱们改不改变它。
终末咱们删除拷贝函数
Auto_Ptr(const Auto_Ptr& source) = delete;Auto_Ptr& operator=(const Auto_Ptr& source) = delete;
这样的AutoPtr类就相当类似范例库的unique_ptr了
unique_ptr只允许从右值更始资源，但不行从左值拷贝资源，咱们使用std::move将左值更始为右值后就不错了。但是被更始的值照旧不行使用了，既然你照旧move了他，那就阐明被move的值不错被更始，编译器是假定措施员知说念这件事的，是以咱们之后再使用照旧被move的变量尔后导致未界说行为，服务在措施员而不是编译器。
Auto_Ptr<A> getResource() {A* res_f = new A();return Auto_Ptr<A>(res_f);}int main() {Auto_Ptr<A> res1 (new A());//Auto_Ptr<A> res2 (res1);// 报错Auto_Ptr<A> res2 (std::move(res1)); // 将左值cast为右值，编译通过Auto_Ptr<A> res3(getResource()); // 传递临时对象，即一个右值，编译通过DoSomeThing(getResource());DoSomeThing(std::move(res3)); // 也能值传递了 ， 但是 res3 在这行之后就照旧被更始了std::cout << "res3 is " << (res3.isNull() ? "null\n" : "not null\n"); // res3 is nullstd::cout <<(*res3).attr_a << std::endl; // 使用照旧被更始的变量， crash！return 0;}终末将上头的代码修改整合，得到一份陋劣的Unique_Ptr竣事：
template<typename T> class Unique_Ptr {private:// 原始指针T* resource_;public:// unique_ptr是只移的，因此删除赋值函数Unique_Ptr(const Unique_Ptr&) = delete;Unique_Ptr& operator=(const Unique_Ptr&) = delete;// 构造函数explicit Unique_Ptr(T* raw_ptr): resource_(raw_ptr) { } // explicit退守隐式调动// 出动构造函数Unique_Ptr(Unique_Ptr&& other):resource_(other.resource_) {other.resource_ = nullptr;}// 出动赋值函数Unique_Ptr& operator=(Unique_Ptr&& other) {if (&other != this) { // 防止自赋值的情况delete resource_;resource_ = other.resource_;other.resource_ = nullptr;}return *this;}// 析构函数~Unique_Ptr() {if (resource_) {delete resource_;resource_ = nullptr;}}// 解援用记号 * 重载T& operator*() const{return *resource_;}// ->记号重载T* operator->() const{return resource_;}};unique_ptr的使用场景作为工场函数的复返值，unique_ptr或者便捷高效地、无感地调动成shared_ptr。工场函数并不知说念调用者是对器复返的对象聘请专属通盘权好，如故分享通盘权更合适。
// 函数声明复返unique_ptrtemplate<typename...TS>std::unique_ptr<Investment>makeInvestment(Ts&&... param);// 用户措施不错取得一个shared_ptr<Investment>， 其中的调动会默许进行std::shared_ptr<Investment> a = makeInvestment(...);
4）std::shared_ptr
与unique_ptr不同，share_ptr对象或者与其他share_ptr对象共同指向合并个指针，里面防卫一个援用计数，每多一个对象经管原指针，援用计数（reference count）就加一，每放弃一个share_ptr，援用计数减一，终末一个被放弃的shared_ptr对象认真对原始指针进行delete操作
从底层数据结构看（下图源自《effective modern c++》），shared_ptr除了保存原始指针外，还会保存一个指向限定块的指针，是以一般情况下(unique_ptr莫得使用函数指针手脚自界说删除器)shared_ptr的大小会比unique_ptr大两倍。限定块是一动态分派在堆内存中的，其中有援用计数、弱计数、以过火他数据(比如自界说deleter、原子操作联系的数据结构)，弱计数是统计指向T object 的weak_ptr数目，这个计数不影响T object的析构，当援用计数 = 0时，T object 就会被放弃，不会管弱计数（weak count）。
图片
shared_ptr 或者被出动也或者被拷贝，被拷贝时援用计数+1，这个援用计数使用原子变量保证线程安全（但只是保证RefCount的线程安全性），被出动时则不需要。因此探讨效劳时，如果或者出动构造一个shared_ptr那就使用出动，不要使用拷贝。
sharedptr的线程安全性？sharedptr使用atomic变量使得计数器的修改是原子的（即上图的RefCount是原子的），但是sheared_ptr这个类自身不是线程安全的，因为通盘这个词SharedPtr对象有两个指针，复制这两个指针的操作不是原子的！更别说sharedptr经管的对象(上图的T Object)是否有线程安全性了，除非这个对象自身有锁保护，不然不可能通过只套一层sharedptr的封装来竣事线程安全性。
对于std::atomic?C++或者提供原子操作是因为多量硬件提供了援救，比如x86的lock指示前缀，它或者加在INC XCHG CMPXCHG等指示前竣事原子操作。
std::atomic比std::mutex快，是因为std::mutex的锁操作会波及到系统调用，比如在linux上会调用futex系统调用，在某些情况下可能堕入内核。
从效劳上探讨，优先使用make_shared而不是胜利new创建shared_ptrshared_ptr类有两个指针，一个指向要经管的对象，一个指向限定块。
如果使用new来创建shared_ptr：
std::shared_ptr<SomeThing> sp(new SomeThing);
编译器则会进行两次内存分派操作，一次为SomeThing的对象分派，一次为限定块分派内存。
如果使用make_shared创建：
auto sp(std::make_shared<SomeThing>())
编译会只会进行一次内存分派，对象与限定块是紧挨着的。
竣事一个陋劣的Shared_Ptr， 其余测试代码见github仓库// 模拟限定块类class Counter {public:std::atomic<unsigned int> ref_count_;Counter():ref_count_(0){}Counter(unsigned int init_count):ref_count_(init_count){ }};// Shared_Ptr模板类template<typename T>class Shared_Ptr{private:Counter* count_;T* resource_;void release() {if (count_ && resource_) { // 防止这里应该判断count_是否为nullptr，可能照旧被移走了if (--count_->ref_count_== 0) {delete resource_;delete count_;resource_ = nullptr;count_ = nullptr;}}}public:// 构造函数explicit Shared_Ptr():count_(new Counter(0))，resource_(nullptr) { }explicit Shared_Ptr(T* raw_ptr):count_(new Counter(1))，resource_(raw_ptr) { }Shared_Ptr(std::nullptr_t nPtr) {release();resource_ = nPtr;count_ = nPtr;}// 析构函数~Shared_Ptr() {release();}// 复制构造函数Shared_Ptr(const Shared_Ptr& other) {resource_ = other.resource_;count_ = other.count_;count_->ref_count_++;}// 赋值构造函数Shared_Ptr& operator=(const Shared_Ptr& other) {if (&other != this) {// delete resource_; // 这里有问题，能胜利delete吗？// delete count_;release();resource_ = other.resource_;count_ = other.count_;count_->ref_count_++;}return *this;}// 出动构造函数// 防止将被出动对象的资源置空Shared_Ptr(Shared_Ptr&& other):resource_(other.resource_)， count_(other.count_) {other.resource_ = nullptr;other.count_ = nullptr;}// 出动赋值函数Shared_Ptr& operator=(Shared_Ptr&& other) {// 防止将被出动对象的资源置空if (this != &other) {release(); // 开释资源resource_ = other.resource_;other.resource_ = nullptr;count_ = other.count_;other.count_ = nullptr;}return *this;} };5）std::weak_ptr
std::weak_ptr是std::shared_ptr的一种补充，它不是颓败出现的，std::weak_ptr昔日通过unique_ptr来启动化，使用了与std::shared_ptr合并个限定块，但是不会加多refcout只会加多weakcount。它既不行实践提领操作，也莫得->操作.
不错通过weak_ptr来构造shared_ptr(调用lock成员函数)，如果shared_ptr所指涉的对象照旧被放弃，那么调动为空指针。这样在使用某个智能指针前，不错先使用weakptr检测智能指针所指涉的对象是否照旧被放弃(调用expire成员函数)， 这是weak_ptr操作原对象的唯一方法(即调动成shared_ptr)
对于限定块与智能指针所经管的对象的内存开释时机如果使用make_shared来创建sharedptr，由于只进行了一次内存分派，那么得比及weakcount = 0时才会回收这块内存
如果使用new来创建sharedptr，这里分别进行了两次内存分派，那么当refcount = 0时，智能指针所经管的对象的内存不错立即回收，但是限定块的内存如故得比及weakcount = 0时才会回收
弱指针的应用场景责罚轮回援用的资源泄漏问题
带有缓存的工场函数：函数复返sharedptr，工场里面使用weak_ptr指涉客户所要创建的对象
不雅察者筹谋模式
为一个类筹谋一个成员函数，复返一个shared_ptr智能指针，指针指向我方？格外的作念法是：
struct Bad{std::shared_ptr<Bad> getptr(){return std::shared_ptr<Bad>(this);}~Bad() { std::cout << "Bad::~Bad() called\n"; }};为什么？因为getptr成员函数会再分派一个限定块来经管Bad的某个对象，如果这个对象照旧被一个shareptr经管的话，那么就可能发生double free运行时格外。具体少量，就如底下这段代码：
// Bad， each shared_ptr thinks it's the only owner of the objectstd::shared_ptr<Bad> bad0 = std::make_shared<Bad>();std::shared_ptr<Bad> bad1 = bad0->getptr();// UB: double-delete of Bad
第一个语句调用make_shared会分派一个限定块，第二个语句调用通过成员函数再次分派一个限定块，但是这两个限定块齐限定合并个对象指针，终末一定会对对象进行两次的free，从而激发double free格外。
正确的作念法是袭取std::enable_shared_from_this，调用它提供的父类方法来赢得指向自身的sharedptr：
class Good : public std::enable_shared_from_this<Good>{public:std::shared_ptr<Good> getptr(){return shared_from_this();}};// 正确的食用状貌：std::shared_ptr<Good> good0 = std::make_shared<Good>(); // 防止必须照旧有一个sharedptr才不错，不然抛异常，详见cppreference的对应代码std::shared_ptr<Good> good1 = good0->getptr();那么enable_shared_from_this是怎么样幸免double free格外的呢？猜一下就能知说念它可能使用了weakptr：
template<class _Tp>class _LIBCPP_TEMPLATE_VIS enable_shared_from_this{mutable weak_ptr<_Tp> __weak_this_; // ...3.4lambda抒发式1）本体
lambda的本体是一个仿函数(functor)，编译器看到lambda抒发式后会产生一个匿名class，这个class重载了()操作符。
比如底下这个仿函数：
class X {int a = 1;public:void operator()(int b) {printf("a + b = %d\n"， a + b);}};X x_functor;它的作用效劳与底下lambda抒发式交流：
auto x_lambda = [a = 1](int b) {printf("a + b = %d\n"， a + b);};两者的调用状貌和调用一个函数的状貌交流：
x_functor(1);x_lambda(1);
编译期，编译器遭逢lambda抒发式则会生成一个匿名仿函数类型(closure type)；运行期，当使用lambda抒发式时，则把柄编译器生成的匿名仿函数类型创建一个对象，该对象本体便是functor对象。
2）语法
lambda抒发式的语法如下：
[拿获值] (参数列表) ->复返类型 {函数体}拿获值
或者拿获本lambda抒发式所处作用域中的局部变量（不包括类的成员变量）或this指针，使其或者在{}内的函数体中不错被使用
拿获状貌有按值和按援用两种
不错空着，这异常于生成了一个莫得成员变量的仿函数
-> 复返类型
昔日可不写，编译器从函数体中自动推导
其中对于拿获的防止点最多：按值和按援用拿获的区别
int main(){int x = 42;auto byvalue = [x] ( ) // 按值拿获局部变量x，记取当lambda抒发式被evaluated时，值就照旧被拿获了{std::cout << "Hello from a lambda expression， value = " << x << std::endl;}; auto byref = [&x] ( ) // 按援用拿获局部变量x{std::cout << "Hello from a lambda expression， value = " << x << std::endl;};x = 7;byvalue(); // 42， 按值拿获且在lambda抒发式被创建时就被拿获，因此不受影响byref(); // 7 ， 按援用拿获因此受影响}按值拿获的变量是只读的，如果要修改它，则应该在参数列表后加上mutable要害字
auto myLamb = [x] ( ) mutable { return ++x; };幸免默许拿获模式，详见effecttive modern C++条件31
按援用的默许拿获状貌容易酿成指针空悬
看似或者拿获成员变量，践诺上则是拿获了this指针，因此也容易酿成指针空悬
默许拿获不行拿获全局变量！
int g = 10;auto kitten = [=]() { return g+1; }; // 默许按值拿获，但是编译器发现g是全局变量，根蒂不需要拿获auto cat = [g=g]() { return g+1; }; // 广义的按值拿获则可能得到预期终结int main() {g = 20;printf(%d %d\n"， kitten()， cat());// 21 11}最佳齐是写成广义拿获的体式，这是C++14援救的特质
auto cat = [g=g]() { return g+1; }; // 按值拿获g auto dog = [&g=g]() { return g+1; }; // 按援用拿获g防止，= 号双方的g是不同的，左边的g是lambda抒发式所处作用域的局部变量，右边的g则是编译器为lambda抒发式生成的functor中的成员变量
3.5四大调动C++比拟于C谈话多出了4种调动，况且也兼容C作风的调动。C作风的调动确实不错调动任何类型，陋劣便捷的同期增大了出错地可能性。
// 两种通用的调动状貌，容易出错double x = 10.3;int y;// C++存在两种通用类型的调动，第二种则是C作风的调动，第一种和第二种的作用交流y = int (x); // functional notation， y = (int) x; // c-like cast notation
C作风的调动或者作念以下通盘的调动 ：
Between two arithmetic types
Between a pointer type and an integer type
Between two pointer types
Between a cv-qualified and cv-unqualified type (陋劣说便是const类型与非const类型的调动)
A combination of (4) and either (1)， (2)， or (3)
C作风调动的污点 ：
They allows casting practically any type to any other type， leading to lots of unnecessary trouble - even to creating source code that will compile but not to the intended result.
The syntax is the same for every casting operation， making it impossible for the compiler and users to tell the intended purpose of the cast.
Hard to identify in the source code.
C++提供了另外四种调动：
1)dynamic_cast
dynamic_cast：只可调动指向class的指针或援用（昔日波及多态），或者确保调动的终结指向决策指针类型的完整对象( Its purpose is to ensure that the result of the type conversion points to a valid complete object of the destination pointer type.)。
1.dynamic_cast或者将类指针进取转型(派生类指针指向基类指针)，这和static_cast相似，不需要被调动的类领有虚函数，而且C++范例划定在这种情况下产生与static_cast一致的底层代码。如下所示，莫得产生编译格外：
class A {};class B : public A{};int main() {B* b = new B();A* d = dynamic_cast<A*>(b); // 子类指针转向父类指针}也不错将实践向下转型(将基类型指针调动成派生类型的指针)，但是知足两个条件调动才智告捷 ：
基类必须有虚函数，即只对那些展现“多态”的类型，才可能实践向下调动。不然编译器报错：
class A{};class B : public A {};int main() {A* a = new A();B* c = dynamic_cast<B*>(a);// 编译器报错： cannot dynamic_cast 'a’ (of type 'class A*’) to type 'class B*’ (source type is not polymorphic)}最起码，父类具有虚函数才不错，这样父子类齐有了虚函数，也就齐有个运行时类信息，才智通过编译：
class A {public:virtual ~A() {}};class B : public A{};int main() {A* a = new A();B* c = dynamic_cast<B*>(a);}2.但是通过编译不代表调动告捷，如果调动后的对象指针照实是决策对象的指针，那么调动告捷。但如果dynamic_cast向下调动失败则会复返nullptr(指针之间的调动)或者抛出异常(援用之间的调动)。措施员通过检查指针，就不错知说念向下转型是否告捷。
class A {public:virtual ~A() {}};class B : public A{};class C {public:virtual ~C() {}};int main() {C* c_ptr = new C();A* a = dynamic_cast<A*>(c_ptr);printf("a = %p\n"， a); // a = (nil)， 阐明调动不告捷}dynamici_cast使用场景：
using namespace std;class Base { virtual void dummy() {} };class Derived: public Base { int a; };int main () {try {Base * pba = new Derived;Base * pbb = new Base;Derived * pd;pd = dynamic_cast<Derived*>(pba); // 调动告捷if (pd==0) cout << "Null pointer on first type-cast.\n";pd = dynamic_cast<Derived*>(pbb); // 这个调动不会告捷但不会抛出异常，只会复返nullptrif (pd==0) cout << "Null pointer on second type-cast.\n";} catch (exception& e) {cout << "Exception: " << e.what();}return 0;}// 终结Null pointer on second type-cast.对于dynamic_cast的竣事旨趣，看了《深度交融C++对象模子》后了解到编译器会将对象的运行时类型信息（RTTI）指针连同虚函数指针一说念放在虚函数表中（RTTI的指针在函数指针的上方），这也便是为什么不具多态意图的class不行实践dynamic_cast的原因，因为这些类莫得虚函数，也就莫得虚函数表，那也莫得场所存放类型信息。
2)static_cast
static_cast： 或者作念与dynamic_cast相似的服务（即类档次指针间进取/向下转型），但是编译器不会在运行期检查（向下）调动后的object指针是否为决策object指针，因此调动是否告捷是由开垦东说念主员我方保证的。static_cast用于有胜利或盘曲关系的指针或援用之间调动。
莫得袭取关系的指针不行用static_cast调动，不错探讨使用reinterpret_cast。
天然static_cast除了不错作念类档次结构指针之间的调动外还不错作念其他好多其他类型的调动:
将void指针调动成任何其他类型的指针，但是会检查void*指针是否由合并类型的指针调动而来（存疑！）（C作风的调动和reinterpret_cast不会检查）
用于基本数据类型之间的调动
static_cast调动两个没讨论系的类指针时会产生编译格外：class A {};class B {};int main() {A* a = new A();B* b = new B();B* c = static_cast<B*>(a); // compiler error ! invalid static_cast from type 'A*’ to type 'B*’A* d = static_cast<A*>(b); // compiler error ! }如果B袭取自A或者A袭取自B，就不会产生编译时格外
class B : public A{};“子类指针调动成父类指针，使用static_cast、dynamic_cast两种中的苟且一种齐会产生交流的代码”。接下来考据这件事为了不至于太陋劣，我在B中加了一个虚函数，这样当子类更始成父类时，编译器将治疗this指针跳过vptr
class A {public:int a = 1;};class B : public A{public:int b = 1;virtual int fun1() {return 1;};};int main() {B* b_ptr = new B();A* a_ptr = static_cast<A*>(b_ptr);A* a_ptr2 = dynamic_cast<A*>(b_ptr);}实验的编译器版块为g++7.5:
g++ cast.cpp -o cast && objdump -d cast > cast.asm
然后找到返汇编文献中的对于cast的联系代码，我删除了一些无关代码：
8e3: 48 8b 45 d8 mov -0x28(%rbp)，%rax # 使用static_cast进行调动8e7: 48 83 c0 08 add $0x8，%rax8f2: 48 89 45 e0 mov %rax，-0x20(%rbp) 8fd: 48 8b 45 d8 mov -0x28(%rbp)，%rax # 使用dynamic_cast进行调动901: 48 83 c0 08 add $0x8，%rax90c: 48 89 45 e8 mov %rax，-0x18(%rbp)
不错看出，dynamic_cast进行调动的逻辑与static_cast交流，换句话说，这里的dynamic_cast根蒂莫得进行“动态”调动。
2)reinterpret_cast
reinterpret_cast或者将任何类型的指针调动成苟且类型，即使这两个类型莫得任何关联(主若是莫得袭取关系)。它只是在两个指针之间陋劣地实践二进制拷贝，不会进行任何检查。也不错将指针调动成整型。
reinterpret_cast确实与C作风的调动不错作念相通多的事，但它依然不行将const的类型的object调动成non const， 不啻reinterpret_cast，以上三种C++的类型调动齐不行将object的const属性去除(但是C作风的调动不管，这亦然它不安全的原因之一)，唯一或者将const对象调动成非const的C++作风的调动是底下的const_cast
3)const_cast
如上所说，这是C++提供的4种调动种的唯一一个不错"抹除"object const属性的调动状貌
4)实战示例
来自CMU15445lab
reinterpret_cast在lab源码中出现的频率很高， 比如 ：
reinterpret_cast<Page *>(bucket_page)->WLatch();// modify bucketreinterpret_cast<Page *>(bucket_page)->WUnlatch();
BucektPage 与 Page根蒂莫得袭取关系是以使用reinterpret_cast调动，但是这对Page中的成员的礼貌由要求。
底下是Page的成员构成:
class Page {.../** The actual data that is stored within a page. */char data_[PAGE_SIZE]{};/** The ID of this page. */page_id_t page_id_ = INVALID_PAGE_ID;/** The pin count of this page. */int pin_count_ = 0;/** True if the page is dirty， i.e. it is different from its corresponding page on disk. */bool is_dirty_ = false;/** Page latch. */ReaderWriterLatch rwlatch_;}其中data_便是践诺page的脱手地址，咱们使用reinterpret_cast把char* 调动为 BucketPage*
bucket_page =reinterpret_cast<HASH_TABLE_BUCKET_TYPE *>(buffer_pool_manager_->FetchPage(bucket_page_id)->GetData());
按照Struct成员再内存中的分散，咱们不错得到底下的暗示图
图片
编译器由低地址向高地址取得内存中的内容并将它阐述为对应的类，不管是Page如故BucketPage齐是正当的不会产生格外。
但如果 data_声明在终末会怎么？图片
因为使用reinterpret_cast充电器，是以编译器不会进行任何检查，只会从低地址一直进取阐述 length of data_ 个字节数为BucketPage， 很显著这是格外的。
本站仅提供存储服务，通盘内容均由用户发布，如发现存害或侵权内容，请点击举报。