1. 智能指针的引入_内存泄漏
为什么需要智能指针？上一篇：
1.1 内存泄漏
上面是异常安全导致的内存泄漏问题，开空间没有释放也可能导致内存泄漏。
什么是内存泄漏？：
内存泄漏指因为疏忽或错误（逻辑错误）造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制（指针丢了），因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
void MemoryLeaks() { int* p1 = (int*)malloc(sizeof(int)); // 1.内存申请了忘记释放 int* p2 = new int; int* p3 = new int[10]; // 2.异常安全问题 Func(); // 这里如果Func函数抛异常n，会导致下一行 delete[] p3未执行，p3没被释放. delete[] p3; }
内存泄漏分类（了解）：
C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)：
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏：
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
1.2 如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测，如Valgrind和Sanitizer。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结 :内存泄漏非常常见，解决方案分为两种：
1. 事前预防型。如智能指针等。
2. 事后查错型。如泄漏检测工具。
2. RAII思想
RAII：是英文Resource Acquisition Is Initialization（资源获取即初始化）的首字母，是一种利用对象生命周期来控制程序资源的简单技术。
这些资源可以是内存，文件句柄，网络连接，互斥量等等。
RAII：在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处：
① 不需要显式地释放资源。
② 采用这种方式，对象所需的资源在其生命期内始终保持有效。
2.1 RAII解决异常安全问题
利用RAII思想设计delete资源的类：
#include <iostream> using namespace std; double Division(int a, int b) { if (b == 0) { throw "Divide by Zero Error"; } else { return ((double)a / (double)b); } } // 利用RAII思想设计delete资源的类 template<class T> class SmartPtr { public: SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout << "delete: " << _ptr << endl; delete _ptr; } protected: T* _ptr; }; void Func() { //1、如果p1这里new 抛异常会如何？ //2、如果p2这里new 抛异常会如何？ //3、如果div调用这里又会抛异常会如何？ //int* p1 = new int; //int* p2 = new int; //cout << Division() << endl; //delete p1; //delete p2; //cout << "释放资源" << endl; SmartPtr<int> sp1(new int); SmartPtr<int> sp2(new int); cout << Division(3, 0) << endl; } int main() { try { Func(); } catch (const char* errmsg) { cout << errmsg << endl; } catch (...) { cout << "unknown exception" << endl; } cout << "return 0;" << endl; return 0; }
运行：
把 Division(3, 0) 改为 Division(3, 1)：
2.2 智能指针原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
// 1、利用RAII思想设计delete资源的类 // 2、重载operator*和opertaor->，具有像指针一样的行为。 // 3、浅拷贝问题（析构两次，下面讲 template<class T> class SmartPtr { public: SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout << "delete: " << _ptr << endl; delete _ptr; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } protected: T* _ptr; };
所谓RAII，就是将资源的生命周期和对象的生命周期绑定。从构造函数开始，到析构函数结束。智能指针就是使用了RAII技术，并且利用对象生命周期结束时，编译器会自动调用对象的析构函数来释放资源。
智能指针的智能就在于资源会被自动释放，不需要显式地释放资源。采用智能指针，对象所需的资源在其生命周期内始终保持有效。
总结智能指针的原理：
1、利用RAII思想设计delete资源的类
2、重载operator*和opertaor->，具有像指针一样的行为。
3、拷贝问题（不同的智能指针的解决方式不一样）
3. auto_ptr
C++98就已经提供了这样的一个智能指针：（注意到上面写着deprecated不推荐使用了）
让上面写的SmartPtr使用编译器自动生成的拷贝构造函数：
#include <iostream> using namespace std; // 1、利用RAII思想设计delete资源的类 // 2、重载operator*和opertaor->，具有像指针一样的行为。 // 3、浅拷贝问题 template<class T> class SmartPtr { public: SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout << "delete: " << _ptr << endl; delete _ptr; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } protected: T* _ptr; }; int main() { SmartPtr<int> sp1(new int); SmartPtr<int> sp2(sp1); return 0; }
上面代码在运行时报错。
智能指针ap2拷贝复制了ap1，此时ap1和ap2都指向同一块动态内存空间。当程序执行结束以后，ap1对象和ap2对象都会销毁，并且会执行各自的析构函数，所以那份动态空间就会被释放两次，所以报错了。怎么解决？：
显式定义一个拷贝构造函数，不能让两个智能指针指向同一份动态内存空间。（但是这样没有很好的解决问题，auto_ptr就是这样设计的）
//auto_ptr #include <iostream> using namespace std; // 1、利用RAII思想设计delete资源的类 // 2、重载operator*和opertaor->，具有像指针一样的行为。 // 3、浅拷贝问题 template<class T> class SmartPtr { public: SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout << "delete: " << _ptr << endl; delete _ptr; } SmartPtr(SmartPtr<T>& ptr) :_ptr(ptr._ptr) { ptr._ptr = nullptr; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } protected: T* _ptr; }; int main() { SmartPtr<int> sp1(new int); SmartPtr<int> sp2(sp1); return 0; }
增加一个名字叫A的类重复上面操作：
class A { public: ~A() { cout << "~A()" << endl; } protected: int _a1 = 0; int _a2 = 0; }; int main() { SmartPtr<A> sp1(new A); SmartPtr<A> sp2(sp1); return 0; }
使用一下库里的auto_ptr试一下：
class A { public: ~A() { cout << "~A()" << endl; } protected: int _a1 = 0; int _a2 = 0; }; int main() { //SmartPtr<A> sp1(new A); //SmartPtr<A> sp2(sp1); auto_ptr<A> sp1(new A); auto_ptr<A> sp2(sp1); return 0; }
和显式定义一个拷贝构造函数的效果一样。auto_ptr到这种情况就崩了：
class A { public: ~A() { cout << "~A()" << endl; } //protected: int _a1 = 0; int _a2 = 0; }; int main() { //SmartPtr<A> sp1(new A); //SmartPtr<A> sp2(sp1); auto_ptr<A> sp1(new A); auto_ptr<A> sp2(sp1); sp1->_a1++; sp1->_a2++; return 0; }
从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr（中）：https://developer.aliyun.com/article/1522496
