为什么要用引用计数?
场景:代码里X是一个非常重要的资源,模块A,B,C都有对其指针的引用,那么为了不出现内存泄露,常规的代码我们要怎么写?
1. A 模块用完X时,需要检查B,C是否还在引用X,如果B,C有一个在用,那么X只要删除掉对A的引用就可以了,
如果B,C对A都已经没有引用了,那么A需要删除对X的引用时,要同时清除掉X。
2.同样B,C在用完X时,也要重复做1里面的事情。
这样,代码将会多了许多的逻辑判断,同时模块B,C还需要对模块A提供查询是否在引用X的接口。
可以不这么恶心吗?
思考:能否A在释放X前,不需要知道是谁在引用X,只要知道有多少人在引用X?
回答:是的,如果只有我用X,那么我就直接删除,如果还有其他人用,我就什么都不管,只要去除掉对X的引用就可以了。 情况就会变的好一些。
那么如何做到能知道资源的引用次数那?
这就需要对每一个资源X的都有一个的计数,这个计数是和资源X的生命周期息息相关的。
那么如何来管理这个计数?怎么能在有模块引用资源X的时候,计数++,模块释放资源X的时候计数--那?
这个就有一定难度了,引用的方式会有很多种,比如 A = X; A.push_back(X); A[100] = X; ...
当然我们可以在代码里的每一处增加和释放资源引用的地方,都加上代码count++,count--;但这亦然很麻烦,维护成本很高。
如何简单些?
能否把对资源的引用和释放,看成是对一个类的拷贝和销毁来完成? 弄一个代理类,里面封装好计数和资源X。
把所有对资源X的引用都理解成对代理类的引用,对代理类的引用都理解成对代理类的拷贝,对代理的释放就是销毁代理类。
这样我们只需要在代理类的拷贝函数里count++ , 代理类的析构做count--就好了。
如果代理类的资源引用计数count 减为0,就看成所有人都释放了对资源X的引用,这时由代理类来完成对资源的销毁。
#ifndef Ref_hpp
#define Ref_hpp
#include <iostream>
#include <string>
template <typename T>
class RefPtr;
template <typename T>
class Ref {
private:
Ref(T *ptr);
~Ref();
friend class RefPtr<T>; //定义指针管理类为友元,因为管理类需要直接操作指针类
/**
* 增加引用计数
*/
void ref();
/**
* 减少引用计数
*
* @param count <#count description#>
*/
void unref();
/**
* 返回引用计数的个数
*
* @return <#return value description#>
*/
int getCount();
private:
int count; //引用计数
T *p; //基础对象指针
};
template <typename T>
Ref<T>::Ref(T *ptr) : p(ptr), count(1) {
}
template <typename T>
Ref<T>::~Ref() {
// count--;
// if (count <= 0) {
// count = 0;
// delete p;
// }
delete p;
}
template <typename T>
void Ref<T>::ref() {
count++;
}
template <typename T>
void Ref<T>::unref() {
count--;
if (count < 0) {
count = 0;
}
}
template <typename T>
int Ref<T>::getCount() {
return count;
}
template <typename T>
class RefPtr {
public:
RefPtr(T *ptr);
RefPtr(const RefPtr<T>&);
~RefPtr();
RefPtr& operator=(const RefPtr<T>&);
T & operator*();
T * operator->();
inline std::string getTag() { return _tag; };
void setTag(const std::string value) { _tag = value; };
inline int getRefCount() { return ref->getCount(); }
private:
Ref<T> *ref;
std::string _tag;
};
/**
* 构造函数
*/
template <typename T>
RefPtr<T>::RefPtr(T *ptr) : ref(new Ref<T>(ptr)), _tag("") {
}
/**
* 构造函数,不需要对参数进行计数操作
*/
template <typename T>
RefPtr<T>::RefPtr(const RefPtr<T> & nref) {
ref = nref.ref;
ref->ref();
_tag = "";
}
/**
* 销毁函数
*/
template <typename T>
RefPtr<T>::~RefPtr() {
ref->unref();
if (ref->getCount() <= 0) {
delete ref;
}
std::cout << this->getTag() << " leave " << ref->getCount() << "次" << std::endl;
}
/**
* 重载操作符=
* 左值引用计数减一,右值引用计数加一
*
* @param rhs <#rhs description#>
*
* @return <#return value description#>
*/
template <typename T>
RefPtr<T> & RefPtr<T>::operator=(const RefPtr<T>& rhs) {
rhs->ref->ref();
ref->unref();
if (ref->getCount() <= 0) {
delete ref;
}
ref = rhs->ref;
return *this;
}
/**
* 重载操作符*
*
* @return <#return value description#>
*/
template <typename T>
T & RefPtr<T>::operator*() {
return *(ref->p);
}
/**
* 重载->操作符
*
* @return <#return value description#>
*/
template <typename T>
T * RefPtr<T>::operator->() {
return ref->p;
}
#endif /* Ref_hpp */