在智能指针类的析构函数里面delete对象成员去对象里面释放垃圾指针等..
#include <iostream>
#include <string.h>
using namespace std;
/* 智能指针垃圾回收器 */
class CMyString;
class CRefCount{
public:
//共享实值 新增加对象
CRefCount(CMyString* realPtr):mCount(0),mPMyString(0){
if(realPtr!=NULL){
mPMyString=realPtr;
}
}
virtual ~CRefCount(){
delete mCount;
}
void addRefenceCount(){
if(mCount==NULL){
mCount=new int(0);
}
++(*mCount);
}
int subRefenceCount(){
/* 0没有对象共享实值mBuf 那么就可以把这片空间释放掉 此时this的虚析构函数 被派生类覆盖所以先掉的派生类*/
if((--(*mCount))==0){
delete this;
return 0;
}
return *mCount;
}
private:
int* mCount;
CMyString* mPMyString;
};
class CMyString:public CRefCount{
public:
CMyString(char* str):CRefCount(this){
char* p=new char[strlen(str)+1];
mBuf=p;
::strcpy(mBuf,str);
}
/*
虚析构方便调用,有继承关系时候方便派生类转基类指针自动调用基类的析构,虚析构会先给
虚表赋值,所以当前虚表调用的就是自己的虚函数喽,调完紧接着调用基类的虚函数
*/
virtual ~CMyString(){
if(mBuf!=NULL){
delete mBuf;
}
}
void fun1(){
cout<<"hello smart"<<endl;
}
private:
char* mBuf;
};
class CSmartPtr{
public:
explicit CSmartPtr(CMyString* ptr=NULL){
mObject=ptr;
if(ptr!=NULL){
ptr->addRefenceCount();
}
}
CSmartPtr(CSmartPtr& obj){
mObject=obj.mObject;
mObject->addRefenceCount();
}
~CSmartPtr(){
if(mObject!=NULL){
mObject->subRefenceCount();
}
}
/* 重载-> 返回被代理的对象的指针,在调用就是真实的对象指针了
其实应该是->->这样但是c++编译器给你完成了可以直接一个->搞定两步
*/
CMyString* operator->(){
return mObject;
}
/*等于产生一个新对象,默认加入共享实值*/
CSmartPtr& operator=(const CSmartPtr& obj){
//释放原来的计数
if (mObject != NULL)
mObject->subRefenceCount();
mObject = obj.mObject;
if (mObject != NULL)
mObject->addRefenceCount();
return *this;
}
/*
代理模式 有smartptr a b c 4个类只
有smartptr能调用fun1这个函数,那么其他的三个类怎么调用fun1呢
很简单,先调用smartptr的fun1 把a or b or c的fun1的结果返回去,或者传给它们都行
*/
void fun1(){
mObject->fun1();
}
private:
CMyString* mObject;
};
void fun1(){
CSmartPtr pa1(new CMyString("helloworld"));
CSmartPtr pa2(pa1);
CSmartPtr pa3(new CMyString("china"));
CSmartPtr pa4;
pa4=pa1;
return;
}
int main(){
fun1();
//pa->fun1();
//pa->fun1();
return 0;
}
总结:
智能指针原理是利用栈对象的自动释放,加->运算符的重载
