文章目录
1. 为什么需要智能指针
在C++11引入异常后，我们的代码就有可能会乱跳，导致释放内存的代码未被执行到造成内存泄漏问题；而且有时我们申请的资源也会忘记释放，如下：
因此，C++11引入智能指针的主要目的是为了更好地管理动态分配的内存，以减少或消除内存泄漏和野指针的问题。
2. 智能指针的使用和原理
2.1 RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效。
下面我们就使用RAII思想设计一个SmartPtr类
namespace my
{
template<class T>
class SmartPtr
{
public:
//构造时获取资源的管理
SmartPtr(T* ptr)
:_ptr(ptr)
{}
//析构时释放资源
~SmartPtr()
{
cout << "~SmartPtr()" << endl;
delete[] _ptr;
}
private:
T* _ptr;
};
}
由于对象在处了作用域以后会自动调用析构函数释放资源，所以就不需要显示的去释放，也不用担心异常安全问题。
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
namespace my
{
template<class T>
class SmartPtr
{
public:
//构造时获取资源的管理
SmartPtr(T* ptr)
:_ptr(ptr)
{}
//析构时释放资源
~SmartPtr()
{
cout << "~SmartPtr()" << endl;
delete[] _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
所以智能指针的原理就是：
- RAII特性
- 重载operator*和opertaor->，具有像指针一样的行为。
智能指针的难点不在于上面这些，在于它的拷贝。针对于它的拷贝问题，库中也提供了几种指针供我们选择
- auto_ptr：其拷贝本质是管理权限的转移
- unique_ptr：不允许拷贝
- shared_ptr：采用引用计数解决析构多次的问题
下面我们就简单模拟实现一下上面几种。
3. 库中智能指针模拟实现
3.1 auto_ptr
C++98版本的库中就提供了auto_ptr的智能指针，下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想。
下面简化模拟实现了一份auto_ptr来了解它的原理
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& p)
{
_ptr = p._ptr;//转移资源的管理权
p._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& p)
{
//检测是否给自己赋值
if (this != &p)
{
//释放当前对象的资源
if (_ptr)
delete _ptr;
//转移p中的资源到当前对象中
_ptr = p._ptr;
p._ptr = nullptr;
}
return *this;
}
~auto_ptr()
{
cout << "~auto_ptr()" << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
结论：auto_ptr是一个失败的设计，很多公司明确要求不能使用auto_ptr。
3.2 unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理
对于unique_ptr的实现，我们可以直接使用delete关键字将其拷贝构造与operator=禁掉
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
unique_ptr(unique_ptr<T>& p) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& p) = delete;
~unique_ptr()
{
cout << "~unique_ptr()" << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
3.3 shared_ptr (重点)
shared_ptr允许拷贝，并且通过引用计数解决了析构多次的问题。
- shared_ptr在其内部，给每个资源都维护着一个引用计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减1。
- 如果
引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源； - 如果
引用计数不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
对于引用计数而言，我们应该对资源被多少对象管理进行计数，不是对对象进行计数，所以计数器这个变量应该和构造函数绑定起来，调用一次构造就是一份新的资源，就应该对应一个新的计数器，所以我们可以在堆上对其进行开辟。
- 构造：每调用一次构造，就应该在堆上开辟一个计数器并初始化为1
shared_ptr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))//一份新的资源，对应一个新的计数器
{}
- 拷贝构造：先复制要拷贝对象的资源与计数器，然后对计数器+1
//调用一次拷贝构造，就是对资源增加一个管理员
shared_ptr(const shared_ptr<T>& p)
:_ptr(p._ptr)
,_pcount(p._pcount)
{
(*_pcount)++;//增加管理员
}
- 析构：检查失去当前管理员是否还有其它管理员，如果有，不需要释放资源；如果没有，需要释放资源
~shared_ptr()
{
//如果是最后一个管理员，需要对资源进行释放
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
}
- operator=：先检查当前对象有无旧资源管理，有就先释放，然后再管理新资源；没有旧资源管理，那就直接管理新资源
shared_ptr<T>& operator=(const shared_ptr<T>& p)
{
//检查是否给自己赋值
if (this != &p)
{
//如果是最后一个管理员，需要对旧资源进行释放
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
//指向新资源，新资源添加管理员
_ptr = p._ptr;
_pcount = p._pcount;
(*_pcount)++;
}
return *this;
}
我们发现operator= 与析构函数存在代码的冗余，因此可以将其单独抽离出来进行复用。
而且对于赋值重载时，必须检查是否是给自己赋值，否则可能会造成空指针问题（自己赋值自己，如果自己是资源的最后一个管理员，会将资源释放，此时再对_pcount解引用就会是空指针异常）
void release()
{
//如果是最后一个管理员，需要对资源进行释放
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& p)
{
//检查是否给自己赋值
if (this != &p)
{
release();
//指向新资源，新资源添加管理员
_ptr = p._ptr;
_pcount = p._pcount;
(*_pcount)++;
}
return *this;
}
~shared_ptr()
{
release();
}
此时我们的shared_ptr已经基本实现完了，但是还存在一个问题：
我们释放资源的功能是写死的，对于普通的内置类型和自定义类型而言没有问题，但是对于数组(delete [ ])以及不是new出来的对象(例如文件的关闭fclose)我们的代码就会有问题，所以我们在构造对象时应该给他传一个可调用对象来控制它的删除。
库里面也是这么做的
由于这个可调用对象的总类很多，所以这里我们可以使用包装器来接收它们。
template<class T>
class shared_ptr
{
private:
T* _ptr;
int* _pcount;
function<void(T*)> _del = [](T* ptr) { delete 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)
{}
void release()
{
//如果是最后一个管理员，需要对资源进行释放
if (--(*_pcount) == 0){
//delete _ptr;
_del(_ptr);
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
}
//调用一次拷贝构造，就是对资源增加一个管理员
shared_ptr(const shared_ptr<T>& p)
:_ptr(p._ptr)
,_pcount(p._pcount)
{
(*_pcount)++;//增加管理员
}
shared_ptr<T>& operator=(const shared_ptr<T>& p)
{
//检查是否给自己赋值
if (this != &p)
{
release();
//指向新资源，新资源添加管理员
_ptr = p._ptr;
_pcount = p._pcount;
(*_pcount)++;
}
return *this;
}
~shared_ptr()
{
release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t i)
{
return _ptr[i];
}
};
3.4 shared_ptr的循环引用问题
查看下面的代码，我们能发现什么？-- 发生了内存泄漏
我们来分析一下它为什么会发生内存泄漏呢？
解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
weak_ptr是一种弱“指针”，它不支持RAII，不管理资源(不支持使用资源构造)，不是常规的智能指针。上述代码weak_ptr的_next和_prev不会增加node1和node2的引用计数。
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
