c++智能指针 c++

智能指针的使用及原理RAII （ Resource Acquisition Is Initialization ）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：不需要显式地释放资源。采用这种方式，对象所需的资源在其生命期内始终保持有效。总结： 1. RAII 特性2. 重载 operator* 和 opertaor-> auto_ptr的实现原理：管理权转移的思想

template class AutoPtr { public: AutoPtr(T* ptr = NULL) : _ptr(ptr) {} ~AutoPtr() { if (_ptr) delete _ptr; } // 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系， // 这样就解决了一块空间被多个对象使用而造成程序奔溃问题 AutoPtr(AutoPtr& ap) : _ptr(ap._ptr) { ap._ptr = NULL; } AutoPtr& operator=(AutoPtr& ap) { // 检测是否为自己给自己赋值 if (this != &ap) { // 释放当前对象中资源 if (_ptr) delete _ptr; // 转移ap中资源到当前对象中 _ptr = ap._ptr; ap._ptr = NULL; } return *this; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; };

unique_ptr的实现原理：简单粗暴防止拷贝

template class UniquePtr { public: UniquePtr(T * ptr = nullptr) : _ptr(ptr) {} ~UniquePtr() { if (_ptr) delete _ptr; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; }private: // C++98防拷贝的方式：只声明不实现+声明成私有 UniquePtr(UniquePtr const &); UniquePtr & operator=(UniquePtr const &); // C++11防拷贝的方式：delete UniquePtr(UniquePtr const &) = delete; UniquePtr & operator=(UniquePtr const &) = delete; private: T * _ptr; };

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。 1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

// sharedPtr#include #include using namespace std; template class SharedPtr { public: SharedPtr(T* ptr = nullptr): _ptr(ptr) , _pRefCount(new int(1)) , _pMutex(new mutex) {} ~SharedPtr() { Release(); } SharedPtr(const SharedPtr& sp) : _ptr(sp._ptr) , _pRefCount(sp._pRefCount) , _pMutex(sp._pMutex) { AddRefCount(); } // sp1 = sp2 SharedPtr& operator=(const SharedPtr& sp) { //if (this != &sp) if (_ptr != sp._ptr) { // 释放管理的旧资源 Release(); // 共享管理新对象的资源，并增加引用计数 _ptr = sp._ptr; _pRefCount = sp._pRefCount; _pMutex = sp._pMutex; AddRefCount(); } return *this; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } int UseCount() { return *_pRefCount; } T* Get() { return _ptr; } void AddRefCount() { // 加锁或者使用加1的原子操作 _pMutex->lock(); ++(*_pRefCount); _pMutex->unlock(); } private: void Release() { bool deleteflag = false; // 引用计数减1，如果减到0，则释放资源 _pMutex->lock(); if (--(*_pRefCount) == 0) { delete _ptr; delete _pRefCount; deleteflag = true; } _pMutex->unlock(); if (deleteflag == true) delete _pMutex; } private: int* _pRefCount; // 引用计数 T* _ptr; // 指向管理资源的指针 mutex* _pMutex; // 互斥锁 }; int main() { SharedPtr sp1(new int(10)); SharedPtr sp2(sp1); *sp2 = 20; cout << sp1.UseCount() << endl; cout << sp2.UseCount() << endl; SharedPtr sp3(new int(10)); sp2 = sp3; cout << sp1.UseCount() << endl; cout << sp2.UseCount() << endl; cout << sp3.UseCount() << endl; sp1 = sp3; cout << sp1.UseCount() << endl; cout << sp2.UseCount() << endl; cout << sp3.UseCount() << endl; system("pause"); return 0; }

std::shared_ptr 的线程安全问题通过下面的程序我们来测试 shared_ptr 的线程安全问题。需要注意的是 shared_ptr 的线程安全分为两方面：1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++ 或 -- ，这个操作不是原子的，引用计数原来是 1 ， ++ 了两次，可能还是 2. 这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数 ++ 、 -- 是需要加锁的，也就是说引用计数的操作是线程安全的。2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。