目录
- 一、智能指针的使用及原理
- 二、auto_ptr
- 三、unique_ptr
- 三、shared_ptr
- 四、weak_ptr
- 五、定制删除器
一、智能指针的使用及原理
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。
比如：为什么智能指针前：
#include"smartptr.h"
class A
{
public:
A(int a)
:_a(a)
{
//cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
//Ting::SmartPtr<A> sp1(new A(10));
//Ting::SmartPtr<A> sp2(new A(20));
A* a = new A(10);
cout << div() << endl;
}
int main()
{
try {
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
使用后：
#include<iostream>
using namespace std;
namespace Ting
{
template<class T>
class SmartPtr
{
public:
SmartPtr(const T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~SmartPtr()
{
if (_ptr)
{
delete _ptr;
}
}
private:
const T* _ptr;
};
}
#include"smartptr.h"
class A
{
public:
A(int a)
:_a(a)
{
//cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
Ting::SmartPtr<A> sp1(new A(10));
Ting::SmartPtr<A> sp2(new A(20));
//A* a = new A(10);
cout << div() << endl;
}
int main()
{
try {
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
二、auto_ptr
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
模拟实现auto_ptr:
template<class T>
class auto_ptr
{
public:
auto_ptr (T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& ap)
{
_ptr = ap._ptr;
//悬空
ap._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
if (_ptr != ap._ptr)
{
if (_ptr)
{
delete _ptr;
}
_ptr = ap._ptr;
//悬空
ap._ptr = nullptr;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~auto_ptr()
{
if (_ptr)
{
delete _ptr;
}
}
private:
T* _ptr;
};
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}
三、unique_ptr
为了解决上面auto_ptr拷贝赋值后因为管理权限转移而造成悬空问题，C++11引入了unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
unique_ptr(const unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~unique_ptr()
{
if (_ptr)
{
delete _ptr;
}
}
private:
T* _ptr;
};
三、shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
下面简化模拟实现了一份shared_ptr来了解它的原理
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
++(*_pcount);
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
//防止自己给自己赋值
if (_ptr != sp._ptr)
{
if (_ptr)
{
delete _ptr;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
int* _pcount;
};
但是shared_ptr再有些场景下会出现循环引用问题。如：
没有调用Node的析构函数。为什么呢？如图：
四、weak_ptr
为了解决shared_ptr循环引用场景，所以又引入了weak_ptr。
下面简化模拟实现了一份weak_ptr来了解它的原理
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(Ting::shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& operator=(Ting::SmartPtr<T>& sp)
{
_ptr = sp.get();
return *this;
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
};
五、定制删除器
上面模拟的shared_ptr只能在少部分场景下使用，在这个场景下使用不了。如：
所以我们可以模拟库里在构造时加个仿函数过去。
属性里也加个，用包装器来申明。
析构函数改成调用仿函数。
完整代码：
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new int(1))
{}
template<class D>
shared_ptr(T* ptr,D del)
:_ptr(ptr)
,_pcount(new int(1))
,_del(del)
{}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
++(*_pcount);
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
//防止自己给自己赋值
if (_ptr != sp._ptr)
{
if (_ptr)
{
delete _ptr;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
_del(_ptr);
delete _pcount;
}
}
T* get()
{
return _ptr;
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
int* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
