文章详细介绍了C++中的智能指针概念，包括RAII原则，以及auto_ptr、unique_ptr和shared_ptr的使用和原理。重点讨论了智能指针如何解决内存管理和异常安全问题，同时提到了循环引用和weak_ptr的作用，以及定制删除器在unique_ptr和shared_ptr中的应用。
长路漫漫，唯剑作伴。
目录
为什么需要智能指针
int div() { int a, b; cin >> a >> b; if (b == 0) throw invalid_argument("除0错误"); return a / b; } void func() { int* p1 = new int[10]; // 这里亦可能会抛异常 int* p2 = new int[10]; // 这里亦可能会抛异常 int* p3 = new int[10]; // 这里亦可能会抛异常 int* p4 = new int[10]; // 这里亦可能会抛异常 try { div(); } catch (...) { delete[] p1; delete[] p2; delete[] p3; delete[] p4; throw; } delete[] p1; delete[] p2; delete[] p3; delete[] p4; } int main() { try { func(); } catch (const exception& e) { cout << e.what() << endl; // ... } return 0;可以发现上面这段代码是典型的异常处理中可能会碰到内存泄漏或析构异常的例子,我们当然可以为每个new[]都尝试着抛出异常,但那样太麻烦了,所以我们引入了智能指针
RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在 对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效。
使用RAII思想管理内存
// 使用RAII思想设计的SmartPtr类 template<class T> class SmartPtr{ public: SmartPtr(T* ptr = nullptr) : _ptr(ptr){ cout << "get " << _ptr << endl; } ~SmartPtr(){ if (_ptr) cout << "delet " <<_ptr<< endl; delete _ptr; } private: T* _ptr; }; void Func(){ int* pa = new int(10); cout << " pa " << pa << endl; SmartPtr<int> sp1(pa); } int main(){ Func(); return 0; }
重载 * 和->
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可 以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
#include<iostream> #include<memory> using namespace std; //使用RAII 思想管理内存 template<class T> class SmartPtr{ public: SmartPtr(T* ptr = nullptr) : _ptr(ptr){ //cout << "get " << _ptr << endl; } ~SmartPtr(){ if (_ptr) //cout << "delet " <<_ptr<< endl; delete _ptr; } T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } private: T* _ptr; }; struct Date{ int _year; int _month; int _day; }; int main(){ SmartPtr<int> sp1(new int); *sp1 = 10; cout << *sp1 << endl; SmartPtr<Date> spDate(new Date); // 需要注意的是这里应该是spDate.operator->()->_year = 2018; // 本来应该是spDate->->_year这里语法上为了可读性，省略了一个-> spDate->_year = 2060; spDate->_month = 6; spDate->_day = 14; cout << spDate->_year << "/" << spDate->_month << "/" << spDate->_day << endl; return 0; }
但是尽管如此，我们仍旧面临拷贝问题和析构问题，这里先抛出问题，文章后面会解释C++智能指针是如何解决这类的问题的，一步一步来，我们会先解决拷贝问题，然后再解决析构问题（定制删除器）
void copy_issue(){ SmartPtr<int> sp1(new int); SmartPtr<int> sp2 = sp1; //这里会析构2次而导致程序异常终止 } void destructor_issue(){ SmartPtr<int> sp1(new int[10]); //这里的析构存在类型不匹配,没办法正确的调用 delete[], //类似的还有文件描述符,也没办法正确 close()... }总结一下智能指针的原理：
- RAII特性
- 重载operator*和opertaor->，具有像指针一样的行为
- 处理拷贝问题
- 定制删除器
C++的智能指针和拷贝问题
auto_ptr (C++98)
auto_ptr的实现原理：管理权转移的思想，
下面简化模拟实现了一份skate::auto_ptr来了解它的原理:
namespace skate{ template<class T> class auto_ptr{ public: auto_ptr(T* ptr) :_ptr(ptr){ } auto_ptr(auto_ptr<T>& sp) //拷贝构造 :_ptr(sp._ptr){ // 管理权转移 sp._ptr = nullptr; } auto_ptr<T>& operator=(auto_ptr<T>& ap){ //赋值重载 // 检测是否为自己给自己赋值 if (this != &ap){ // 释放当前对象中资源 if (_ptr) delete _ptr; // 转移ap中资源到当前对象中 _ptr = ap._ptr; ap._ptr = NULL; } return *this; } ~auto_ptr(){ if (_ptr){ cout << "delete:" << _ptr << endl; delete _ptr; } } // 像指针一样使用 T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } private: T* _ptr; }; } //结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr int main(){ skate::auto_ptr<int> sp1(new int); *sp1 = 10; skate::auto_ptr<int> sp2(sp1); // 管理权转移 //sp1悬空 *sp1 = 20; //空指针异常 *sp2 = 30; cout << *sp2 << endl; cout << *sp1 << endl; return 0; }unique_ptr (C++11)
C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理// C++11库才更新智能指针实现 // C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr // C++11将boost库中智能指针精华部分吸收了过来 // C++11->unique_ptr/shared_ptr/weak_ptr // unique_ptr/scoped_ptr // 原理：简单粗暴 -- 防拷贝 namespace skate{ template<class T> class unique_ptr{ public: unique_ptr(T* ptr) :_ptr(ptr){ } ~unique_ptr(){ if (_ptr){ cout << "delete:" << _ptr << endl; delete _ptr; } } // 像指针一样使用 T& operator*(){ return *_ptr; } T* operator->(){ return _ptr; } unique_ptr(const unique_ptr<T>& sp) = delete; unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete; private: T* _ptr; }; }std::shared_ptr (C++11)
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
class MyClass{ public: MyClass(){ std::cout << "MyClass constructor called" << std::endl; } ~MyClass(){ std::cout << "MyClass destructor called" << std::endl; } }; int main(){ std::shared_ptr<MyClass> ptr1(new MyClass); //调用构造函数 std::cout << ptr1.get() << " _ptr-> ptr1.use_count() = " << ptr1.use_count() << std::endl; std::shared_ptr<MyClass> ptr2 = ptr1;//调用赋值重载 计数++ std::cout << ptr2.get() << " _ptr-> ptr2.use_count() = " << ptr2.use_count() << std::endl; std::shared_ptr<MyClass> ptr3(ptr1);//调用拷贝构造 计数++ std::cout << ptr3.get() << " _ptr-> ptr3.use_count() = " << ptr3.use_count() << std::endl; ptr1.reset(); //计数-- ptr2.reset();//计数-- ptr3.reset();//计数为0 调用析构 std::cout << ptr3.get() << " _ptr-> ptr3.use_count() = " << ptr3.use_count() << std::endl; return 0; }
sheared_ptr 的简化实现
template<class T> class shared_ptr { public: void Release()// 释放指向的对象和引用计数 { if (--(*_pCount) == 0 && _ptr) //计数为0进行析构 { cout << "delete" << _ptr << endl; delete _ptr; _ptr = nullptr; delete _pCount; _pCount = nullptr; } } // RAII思想 shared_ptr(T* ptr) :_ptr(ptr) , _pCount(new int(1)) {} ~shared_ptr() { Release();//析构先时候 --计数,后确认析构 } shared_ptr(const shared_ptr<T>& sp) :_ptr(sp._ptr) , _pCount(sp._pCount) { (*_pCount)++; } // sp1 = sp3 shared_ptr<T>& operator=(const shared_ptr<T>& sp) { //if (this != &sp) if (_ptr != sp._ptr) { Release();//先 --计数,后确认析构 _ptr = sp._ptr; _pCount = sp._pCount; ++(*_pCount); } return *this; } // 像指针一样 T& operator*() { return *_ptr; } T* operator->() { return _ptr; } T* get() const { return _ptr; } int use_count() { return *_pCount; } private: T* _ptr; int* _pCount; };需要注意的是，这只是一份简单的shared_ptr模拟实现，并没有考虑线程安全等方面的问题。实际上，C++11中的标准库中的shared_ptr实现更加复杂和完善，具有线程安全等特性。
关于循环引用的问题（Circular reference）
循环引用是指两个或多个智能指针对象直接或间接地引用彼此，形成一个引用链，导致资源无法正确释放。当涉及的对象之间的引用计数永远不会降为0时，就会发生循环引用问题。
这种情况下，我们可以使用weak_ptr来打破循环引用，从而避免内存泄漏的问题。
循环引用分析：
- node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
- node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
- node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
- 也就是说_next析构了，node2就释放了。
- 也就是说_prev析构了，node1就释放了。
- 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。
weak_ptr 打破循环引用（C++11）
weak_ptr 的简化实现
// 不直接参与指向资源的释放管理 template<class T> class weak_ptr { public: weak_ptr() :_ptr(nullptr) {} weak_ptr(const shared_ptr<T>& sp) :_ptr(sp.get()) {} weak_ptr<T>& operator=(const shared_ptr<T>& sp) { if (_ptr != sp.get()) { _ptr = sp.get(); } return *this; } // 像指针一样 T& operator*() { return *_ptr; } T* operator->() { return _ptr; } public: T* _ptr; }; }
定制删除器
定制删除器的使用
class Date{ public: ~Date(){ cout << "~Date()" << endl; } private: int _year = 1; int _month = 1; int _day = 1; }; // unique_ptr/shared_ptr 默认释放资源用的delete // 如何匹配申请方式去对应释放呢？ template<class T> struct DeleteArray{ void operator()(T* ptr){ cout << "delete[]" << ptr << endl; delete[] ptr; } }; template<class T> struct Free{ void operator()(T* ptr){ cout << "free" << ptr << endl; free(ptr); } }; struct Fclose{ void operator()(FILE* ptr){ cout << "fclose" << ptr << endl; fclose(ptr); } }; void test_unique(){ cout << "\ntest_unique()\n"; // unique_ptr传类型 std::unique_ptr<Date> up1(new Date); std::unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]); std::unique_ptr<Date, Free<Date>> up3((Date*)malloc(sizeof(Date) * 5)); std::unique_ptr<FILE, Fclose> up4((FILE*)fopen("Test.cpp", "r")); } void test_shared(){ cout << "\ntest_shared()\n"; // shared_ptr传对象 std::shared_ptr<Date> sp1(new Date[5], DeleteArray<Date>()); std::shared_ptr<Date> sp2(new Date[5], [](Date* ptr){cout << "lambda delete[] " << ptr << endl;; delete[] ptr; }); } //定制删除器 int main(){ test_unique(); test_shared(); return 0; }unique_ptr 定制删除器的模拟实现
ps：
C++11中的标准库中的shared_ptr实现更加复杂和完善，具有线程安全等特性。封装的也更加彻底，这里就不写模拟实现了
相关链接 :
https://cplusplus.com/reference/memory/auto_ptr/
https://cplusplus.com/reference/memory/unique_ptr/
1550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
