RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源的技术
- 不需要显示的释放资源
- 对象的资源在其生命周期类保持有效
通常控制的资源：动态申请的内存、文件描述符、互斥量、网络连接等
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象 。
智能指针原理
-
RAII特性
-
具有像指针一样的行为
（重载
operator*()和operator->()）
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
//RAII特性
~SmartPtr()
{
if (_ptr)
{
delete _ptr;
}
}
//具有像指针一样的行为
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
指针允许拷贝和赋值，使多个指针对象指向同一块资源，即浅拷贝。如果使用上述代码的SmartPtr，并且进行过拷贝赋值，那么很可能会导致野指针问题。这样的话对于SmartPtr的重点就在解决：
- 智能指针对象的拷贝问题
auto_ptr
C++98中引入的智能指针
通过管理权转移的方式解决智能指针的拷贝问题，保证一个资源在任何时刻都只有一个对象在对其进行管理，这时同一个资源就不会被多次释放了
- 拷贝构造函数中，用传入对象来初始化当前对象，并将传入对象管理资源的指针置空
- 赋值运算符重载中，先将当前管理的资源释放，然后再接管传入对象管理的资源，并将传入对象管理资源的指针置空
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr = nullptr)
: _ptr(ptr)
{}
~auto_ptr()
{
if (_ptr)
{
cout << "Delete:" << _ptr << endl;
delete _ptr;
}
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
//智能指针对象的拷贝问题
// 拷贝构造函数
auto_ptr(auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
// 赋值运算重载
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
if (this != &ap)//防止自己给自己赋值的操作
{
if (_ptr)//释放原来管理的资源
{
delete _ptr;
}
//管理权转移
_ptr = ap._ptr;
ap._ptr = nullptr;
}
return *this;
}
private:
T* _ptr;
};
将一个auto_ptr对象赋值给另一个对象，原本的auto_ptr对象将拥有NULL指针，此时出现“悬垂指针”问题，比如：继续使用原对象，导致空指针解引用等问题。
由于这个缺陷，导致auto_ptr成为一种过时的智能指针，而后C++11中有更加安全可靠的选择。
unique_ptr
C++11中引入的智能指针
通过简单粗暴的防止对智能指针对象进行拷贝，这样也能保证资源不会被多次释放
- 拷贝构造函数和赋值运算符被显式删除
template<class T>
class unique_ptr
{
// 防拷贝 C++98 只声明不实现
//private:
//unique_ptr(unique_ptr<T>& ap);
//unique_ptr<T>& operator=(unique_ptr<T>& ap);
public:
unique_ptr(T* ptr = nullptr)
: _ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
{
cout << "Delete:" << _ptr << endl;
delete _ptr;
}
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
// 防拷贝 C++11
unique_ptr(unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
private:
T* _ptr;
};
shared_ptr
C++11引入的更安全可靠的智能指针
通过引用计数的方式来实现多个shared_ptr对象之间共享资源
- 每个被管理的资源都有一个引用计数，初始化为1
- 当新对象管理该资源时，引用计数+1，当某对象不再管理该资源时，引用计数-1
- 当该引用计数为0时，会将该资源释放
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _pcount(new int(1))
{}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
//析构后不再管理该资源
~shared_ptr()
{
if (--(*_pcount) == 0)
{
if (_ptr != nullptr)
{
delete _ptr;
_ptr = nullptr;
}
delete _pcount;
_pcount = nullptr;
}
}
//拷贝构造函数
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
{
(*_pcount)++;
}
//赋值，不再管理原资源
shared_ptr& operator=(shared_ptr<T>& sp)
{
if (_ptr != sp._ptr) //避免管理同资源的对象间赋值
{
if (--(*_pcount) == 0) //引用计数--
{
delete _ptr;
delete _pcount;
}
//管理同一块资源
_ptr = sp._ptr;
_pcount = sp._pcount;
(*_pcount)++; //引用计数++
}
return *this;
}
private:
T* _ptr; //管理的资源
int* _pcount; //管理的资源对应的引用计数
};
引用计数使用动态申请的空间
引用计数本身也是智能指针所管理/共享的资源，使用指针类型可以进行管理/共享。
如果使用int型变量，管理同一个资源时无法很好保证引用计数的一致性；如果使用static变量，同类的实例化对象其实是共享该静态成员的，即使管理的不是同一个资源。
引用计数++/- -操作的线程安全问题
可以使用mutex* _pmutex互斥锁来对引用计数进行加锁操作，同样的互斥锁也使用指针类型。
定制删除器
share_ptr并不是只管理以new方式申请到的内存空间，也可能是以new[]的方式申请到的空间，或管理的是一个文件指针。此时就需要使用特定的删除器
template<class T>
struct Delete
{
void operator()(T* ptr)
{
//1. delete[] ptr
//2. close(ptr)
delete ptr;
}
};
template<class T, class D = Delete<T>>
class shared_ptr
{
void Release()
{
if (--(*_pCount) == 0)
{
D()(_ptr); // 定制删除器
delete _pCount;
}
}
~shared_ptr() { Release(); }
。。。
};
循环引用问题
虽然在赋值运算符重载里面用_ptr != sp._ptr进行判断，避免管理同资源的对象间赋值，导致的重复计数问题。但是还是存在特殊的场景，诱发引用计数的错误----循环引用
struct ListNode
{
shared_ptr<ListNode> _next;
share_ptr<ListNode> _prev;
};
int main()
{
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
//同类型(share_ptr)才能进行赋值拷贝
node1->_next = node2;
node2->_prev = node1;
return 0;
}
只有当引用计数为0时资源才会释放。第一个节点引用计数变为0取决于第二个节点的prev指针，因此需要释放第二个节点，即：第二个节点的引用计数变0，这一步又取决于第一个节点的next指针…
因此第一个节点是释放取决于第二个节点，而第二个节点又需要第一个节点先释放。
weak_ptr
C++11引入的智能指针，可以与shared_ptr协同工作
在不增加对象引用计数的情况下观测和访问共享对象，不进行资源管理
- 支持使用shared_ptr对象来进行构造/赋值
// 辅助型智能指针，使命配合解决shared_ptr循环引用问题
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
//用share_ptr构建对象
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr(const weak_ptr<T>& wp)
:_ptr(wp._ptr)
{}
//用share_ptr对象进行赋值拷贝
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
public:
T* _ptr;
};
对于shared_ptr问题进行修改
struct ListNode
{
weak_ptr<ListNode> _next;
weak_ptr<ListNode> _prev;
};
int main()
{
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
//weak_ptr支持shared_ptr类型的赋值拷贝
node1->_next = node2;
node2->_prev = node1;
return 0;
}
希望暂时访问一个shared_ptr所指向的对象而不想把它引用计数加1时，可以使用weak_ptr代替 shared_ptr。
🦀🦀观看~~
