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;
};
总结
本文讲述了几个智能指针的优缺点和模拟实现。