文章目录
- RAII
- 一、auto_ptr
- 二、unique_ptr
- 三、shared_ptr
- shared_ptr的循环引用问题
- 四、weak_ptr
- 总结
RAII
RAII就是将资源交给一个对象管理，这个对象能进行正常的管理和释放资源。
一、auto_ptr
auto_ptr的问题是：在拷贝构造和赋值重载时，会将自己资源的管理权转移给对方。
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//ap3(ap1)
auto_ptr(auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;//必须置空，否则两个指针对象管理同一块空间，会调用析构两次
}
operator=(auto_ptr<T>& ap)
{
_ptr = ap._ptr;
ap._ptr = nullptr;
}
~auto_ptr()
{
delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理
//自定义类型调用它自己的析构
_ptr = nullptr;
}
private:
T* _ptr;
};
这个auto_ptr实际不会用，太挫了。
但面试可能要手撕，也要会。
二、unique_ptr
unique_ptr 简单粗暴地禁止了拷贝和赋值重载，那就解决了上面auto_ptr的管理权转移问题了。
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
unique_ptr(unique_ptr<T>& up) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;
~unique_ptr()
{
delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理
//自定义类型调用它自己的析构
_ptr = nullptr;
}
private:
T* _ptr;
};
所以unique_ptr就比较适用于，一个指针独占一个资源的情况。
三、shared_ptr
shared_ptr使用了引用计数器，最开始new对象时，计数器为1。
而当其他的同类型的指针对象也指向该对象时，计数器+1。
当有指针对象调用析构函数时，判断计数器是否为0，如果不为0，表明我这个对象还有其他的shared_ptr在管理，不需要delete，让计数器-1即可。
如果计数器为0，表明当前的shared_ptr是最后一个指针对象管理资源了。就delete。
shared_ptr解决了auto_ptr的管理权转移问题，也解决了unique_ptr的不让拷贝和赋值的问题。
注意的问题：
- 1.不能赋值给自己，否则计数器会++。
还有一个问题：默认的析构函数的处理方式是delete ptr。
如果指针管理的资源是T[]，或者是fopen，或者是malloc的呢？
如果还使用默认的处理方式delete ptr，就会出现问题。
资源是T[],就得用delete[] ,是fopen，就得用fclose，是malloc，就得用free。
所以在传参的时候，就需要传处理方法过来了。（可以传对象的方法，可以传lambda，可以传包装器。
所以就需要将析构函数，设置成一个对象/包装器，调用的就是传进来的析构方法。 - 2.实现赋值重载的时候，有很多细节。
-
- 不能自己给自己赋值
-
- 在把对方赋值给自己之前，需要把自己所指向的计时器减减，因为我要只向其他的计时器了。如果减减后的计时器为0，说明这块资源只有我一个指针在管理，现在我要只想其他资源，所以我要先释放我现在的资源才能去指向其他资源，否则就会出现内存泄露问题。
- 在把对方赋值给自己之前，需要把自己所指向的计时器减减，因为我要只向其他的计时器了。如果减减后的计时器为0，说明这块资源只有我一个指针在管理，现在我要只想其他资源，所以我要先释放我现在的资源才能去指向其他资源，否则就会出现内存泄露问题。
template<class T>
class shared_ptr
{
public:
//1) 使用定制删除器，解决一个当new []时，需要delete []的问题
//2) 还有 使用malloc时，需要free配对
//3) 使用fopen，需要fclose配对
template<class D>
shared_ptr(T* ptr,D del)
:_ptr(ptr)
,_pcount(new int(1))
,_del(del)
{}
//然而这里有一个问题，模板D不是全局的，而是只针对这个构造函数
//所以应该如何创建_del对象呢？
//使用包装器
//function <void(T*)> _del;
//因为不管是上面三种情况的哪一种，共同点都是使用的仿函数的返回值都是void，指针类型都是T*
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//sp3(sp1)
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount) //让他们的引用计数器指针指向同一个计数器
{
++(*_pcount);
}
//sp5 = sp2
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
//不能自己赋值给自己，否则引用计数器会++
//这样判断是可以的，只要不同的对象指向同一个资源空间，这几个对象之间的赋值都是相当于自己给自己赋值
if(_ptr == sp._ptr)
//if (_pcount == sp._pcount) //这也可以
{
return *this;
}
//赋值前，需要将之前的计数器--，如果计数器为0，就释放资源
//因为我要指向其他资源了，我原来的资源的计数器当然要--
if (--(*sp._pcount) == 0)
{
_del(sp._ptr);
delete sp._pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
return *this;
}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
_del(_ptr);
delete _pcount;
_pcount = nullptr;
_ptr = nullptr;
}
}
T* get() const
{
return _ptr;
}
int use_count() const
{
return *_pcount;
}
private:
T* _ptr;
int* _pcount;
//包装器
//包装器包装的_del是D类型，这个D也不知道是什么类型，
//包装器可以包装仿函数，包装对象的方法等。
//如果只是普通的指针析构，那就给一个缺省。
function <void(T*)> _del = [](T* ptr) {delete ptr; };
//dzt::shared_ptr<int> svr(new int); //这样的方式，就是没传处理方式，那默认就是用缺省。
//dzt::shared_ptr<int> svr(new int[10],[](int* ptr){delete[] ptr};
//这样的传参方式，就用delete[]解决
};
shared_ptr的循环引用问题
循环引用问题是两个节点的shared_ptr指针互相指向的时候，引用计数器都会+1，这就出现了互相的计数器都是2.在析构时，都变成1，此时就出现了，到底谁先析构的问题。
就一直死循环了。
不过，shared_ptr能解决日常生活99%的问题，它只有一个缺点，就是循环引用问题。
解决办法：weak_ptr，weak_ptr是专门解决循环引用这个问题的。
weak_ptr没有RAII，没有引用计数，不参与对象资源的管理和释放，只是一个简单的访问资源的操作。
四、weak_ptr
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(T* ptr)
:_ptr(ptr)
{}
//weak_ptr必须支持一个shared_ptr构造weak_ptr的构造函数
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//类外面无法直接访问类的私有成员
_ptr = sp.get();
return *this;
}
//weak只支持访问资源的操作
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//weak_ptr不参与对象资源的管理和释放，所以没有析构函数
private:
T* _ptr;
};
总结
本文讲述了几个智能指针的优缺点和模拟实现。
