目录
前言
一.智能指针的原理
1.1 RAII思想
1.2 原理
二.智能指针的分类
2.1 auto_ptr介绍
2.2 unique_pt介绍
前言
由于C++没有GC(垃圾回收器)，程序员从堆上申请的资源，打开的文件，创建的套接字需要我们手动释放和关闭。
但是可能会出现两个问题：
- 异常安全问题。申请完资源，由于异常需要捕捉，使得执行流不会按顺序进行，导致资源还没有释放和关闭，就跳到别的地方执行了。
- 由于需要程序员手动释放和关闭，可能会有忘记释放和关闭的问题。
这样就会导致资源的泄漏。计算机的资源是有限的，导致我们可以使用的资源越来越少。
智能指针是针对我们从堆上申请的空间，比如：new和malloc出来的空间。使得智能指针来帮我们释放空间，不需要我们来手动释放了。
一.智能指针的原理
1.1 RAII思想
RAII是一种了利用对象生命周期来控制程序资源(如：内存，文件，套接字，互斥量等)的技术。
在对象构造时获得资源，使得堆资源的控制在对象的生命周期内都有效，最后在对象析构的时候释放资源。
实际上我们是将资源的管理托管给了一个对象。这样做有两个好处：
- 不需要显示的释放资源。
- 资源的控制在对象生命周期内都有效。
利用RAII实现一个最简单的智能指针。
#pragma once #includeusing namespace std; template class SmatrPrt{ private: T* _ptr; public: //将外面申请的资源，托管给类的成员 SmatrPrt(T* ptr = nullptr) :_ptr(ptr) {} //在对象析构时，自动释放资源 ~SmatrPrt(){ if (_ptr){ cout << "delete ptr" << endl; delete _ptr; } } }; #include "SmartPtr.h" void test(){ //将申请的资源托管给了sp对象 //当对象空间释放会调用析构函数，释放资源 SmatrPrt sp(new int); } int main(){ test(); system("pause"); return 0; }
1.2 原理
智能指针的原理利用了RAII思想，并且还需要让智能指针具有指针的功能。即，需要重载operator*和operator->的函数。
之后在使用指针时，只需要像指针一样控制对象即可。
#pragma once #includeusing namespace std; template class SmatrPrt{ private: T* _ptr; public: //将外面申请的资源，托管给类的成员 SmatrPrt(T* ptr = nullptr) :_ptr(ptr) {} T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } //在对象析构时，自动释放资源 ~SmatrPrt(){ if (_ptr){ cout << "delete ptr" << endl; delete _ptr; } } }; #include "SmartPtr.h" void test(){ SmatrPrt sp(new int); //像指针一样操作对象 *sp = 20; cout << *sp << endl; } int main(){ test(); system("pause"); return 0; }
总结指针指针：
- 利用RAII思想，实现自动释放资源。
- 重载operator*和operator->，使其具有和指针一样的行为和功能。
二.智能指针的分类
上面的代码有一个bug：
原因：
用sp1拷贝构造sp2，由于是浅拷贝。会使得两个对象的成员变量指向同一块空间。两个对象在析构时，导致一块空间释放了两次。所以程序会奔溃。
随着C++的发展，有三个解决方案，一个方案对应着一种智能指针。
- 将指针的管理权转移给另外一个对象。对应C++98的auto_ptr。
- 防止拷贝。对应C++11的unique_ptr。
- 引用计数。对应C++11的shared_ptr。
注意：智能指针都包含在memory的库中，要使用智能指针必须包含这个库。
2.1 auto_ptr介绍
auto_ptr的原理是：将资源的管理权由一个对象转移给另外一个对象。
但是这样会有一个问题，如果重新访问ap1，就会出现问题。这种方式在实际在编程中用得少。
模拟实现auto_ptr：
注意：赋值防止自己给自己赋值，还需要释放当前对象以前的资源。
templateclass AutoPtr{ private: T* _ptr; public: AutoPtr(T* ptr = nullptr) :_ptr(ptr) {} //拷贝构造 //将ap资源的管理权交当前对象 AutoPtr(const AutoPtr & ap){ _ptr = ap._ptr; ap._ptr = nullptr; } AutoPtr & operator=(const AutoPtr & ap){ //防止自己给自己赋值 if (this != &ap){ //释放之前的资源 if (_ptr){ delete _ptr; } _ptr = ap._ptr; ap._ptr = nullptr; } return *this; } T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } //在对象析构时，自动释放资源 ~AutoPtr(){ if (_ptr){ cout << "delete ptr" << endl; delete _ptr; } } };
2.2 unique_pt介绍
针对auto_ptr的不足，C++11根据自己的一些语法，设计了一种更靠谱的智能指针，unique_ptr。
原理：直接简单粗暴，将构造和拷贝构造直接禁止编译器默认生成。
unique_ptr模拟实现：
#pragma once #includeusing namespace std; template class UniquePtr{ private: //C++98，将拷贝构造和赋值，显示声明，设为私有 //外部无法调用 UniquePtr(UniquePtr & up); UniquePtr & operator=(UniquePtr & up); T* _ptr; public: //将外面申请的资源，托管给类的成员 UniquePtr(T* ptr = nullptr) :_ptr(ptr) {} //利用C++11语法，禁止编译器默认生成 UniquePtr(UniquePtr & up) = delete; UniquePtr & operator=(UniquePtr & up) = delete; T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } //在对象析构时，自动释放资源 ~UniquePtr(){ if (_ptr){ cout << "delete ptr" << endl; delete _ptr; } } };
2.3 shared_ptr介绍
shared_ptr原理：在类中增加一个成员变量用来计数。每次调用一次拷贝构造和赋值重载函数，即每增加一个管理者，计数加1。没析构一个管理者对象，计数器减1，直到减为0，才真正释放资源。
- shared_ptr内部，给每一份资源维护了一个计数器，用来记录该份资源被几个对象共享。
- 在对象被销毁，也就是调用析构时，说明不在管理该资源，计数器减1。
- 如果引用计数等于0，说明当前对象是最后一个使用该资源的对象，必须释放资源。
- 当引用计数不等于0，说明还有对象在管理资源，不能释放资源。
计数器如何设置：
由于当前计数器属于同一资源的对象，可以将计数器设计成一个指针。
不能设计成引用，引用要引用外部变量，需要外部管理。也不能设计成静态成员变量，静态成员变量，属于整个类，如果当前类要同时管理其它资源计数器就乱了。
线程安全问题：
由于引用了一个计数器。计数器自增(++)，自减(--)和判断的行为不是原子的。当多个线程进入，会导致线程安全问题。从而导致资源没有释放，造成内存泄漏。
为了保证线程安全，可以在shared_ptr类中，再增加一把锁。由于同一份资源的对象要看到同意把锁，所以，锁也需要声明成指针类型。
shared_ptr模拟实现：
注意：
- 在赋值重载函数中，首先需要判断是否是自己给自己赋值；
- 其次，不能直接释放被赋值对象的资源，需要先将计数器减1(当前对象不管理了)，当计数器等于0，说明没有其它对象管理当前资源，才将资源释放。
- 在析构函数中，也是需要将计数器减为0 了，才能将资源释放。
- 释放资源时注意，需要先解锁了，再释放锁的资源。
- 在计数器自增，自减和判断前需要加锁。
#includetemplate class SharedPtr{ private: T* _ptr; int* _count; mutex* _mt;//防止多线程安全问题 private: void AddCount(){ _mt->lock(); (*_count)++; _mt->unlock(); } void ReleasePtr(){ //是否需要删除锁 bool flag = true; //加锁，防止线程安全 _mt->lock(); (*_count)--; if ((*_count) == 0){ delete _ptr; delete _count; flag = false;//锁要在外面删除，需要解锁 } _mt->unlock(); //删除锁 if (flag == false){ cout << "delete" << endl; delete _mt; } } public: //将外面申请的资源，托管给类的成员 SharedPtr(T* ptr = nullptr) :_ptr(ptr) , _count(new int(1))//申请一份资源，初始化为1 , _mt(new mutex) {} SharedPtr(SharedPtr & sp){ _ptr = sp._ptr; _count = sp._count; _mt = sp._mt; AddCount(); } SharedPtr & operator=(SharedPtr & sp){ //防止自己给自己赋值 if (this != &sp){ //是否管理资源 if (_ptr){ ReleasePtr(); } _ptr = sp._ptr; _count = sp._count; _mt = sp._mt; AddCount(); } return *this; } T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } //在对象析构时，自动释放资源 ~SharedPtr(){ ReleasePtr(); } };
shared_ptr缺陷：
循环引用问题：
一种情况：
当循环引用时，shared_ptr会出现资源没有释放的问题。
解决方案：
C++11增加了一个weak_ptr专门来解决shared_ptr循环引用的问题。
原理是：weak_ptr的成员变量是shared_ptr，不在具有RAII的思想，只是具有指针的功能，也就是，不会释放资源，也不会将计数器计数。
使用weak_ptr前提是，知道是循环引用了。
templateclass WeakPtr{ private: T* _wptr; public: WeakPtr(T* wptr = nullptr){ _wptr = wptr; } //用shared_ptr构造 WeakPtr(const SharedPtr & sp){ _wptr = sp.GetPtr(); } WeakPtr & operator=(const SharedPtr & sp){ _wptr = sp.GetPtr(); return *this; } //具有指针的功能 T* operator->(){ return &_wptr } T& operator*(){ return *_wptr; } };
上面问题的改造：
删除器：
shared_ptr类里默认的在析构函数里释放资源使用的是delete。但是当我们申请出来的不是一个对象，而是多个对象时：
于是C++11增加了一个删除器，可以根据申请对象的不同，设计删除动作，传入shared_ptr中。
实际用法是，写一个仿函数类(写一个类，从在operator()函数，函数实现是需要删除资源的动作)，实例化对象，传入shared_ptr中。
templateclass Del{ public: void operator()(T* ptr){ delete[] ptr; } }; class DelFle{ public: void operator()(FILE* ptr){ fclose(ptr); } }; void test(){ Del d; shared_ptr sp1(new int[10], d); DelFle df; shared_ptr sp2(fopen("text.txt", "w"), df); }
