| 发布日期：2024-08-09 07:01 点击次数：152 |
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除了不错作念类端倪结构指针之间的养息外还不错作念其他好多其他类型的养息:
组选类型判断：最近5期排列三开出2次组六号码，本期重点关注组六号码出现。
也因此，刮刮乐“翻6倍”一上市就备受“刮奖控”追捧，中奖捷报频传，陕西省彩民好运不断。这不，西安雁塔再传喜讯，高女士（化名）刮中最高奖金60万！
将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， 很较着这是轻佻的。
本站仅提供存储服务，整个内容均由用户发布，如发现存害或侵权内容，请点击举报。