C++中没有内存管理机制,所以对于动态申请的内存,如果忘记delete或者程序崩溃导致未执行delete操作,则容易造成内存泄露,所以就出现了智能指针类,用于管理指针对象,使指针对象可以通过析构函数进行释放。下面我要说的是比较片面的一个,主要用于管理对指向同一指针对象的共享,方法是计数的方法。
思想:对于new的一个对象a,通过计数来统计有多少个指针对象指向它,析构一次,则计数次数减去1,那么进行析构的时候,如果计数变为0,则释放a。由此达到对指针对象的管理。
下面详细代码:
1、首先创建一个计数类,用于统计次数,所有变量函数都设为private,友元类为智能指针,因为只有智能指针需要对它进行访问。
class count
{
template<class T> friend class smartPointer;//绑定友元类模板
count(int a):use(a){}
~count()
{
}
int use;//用于统计个数
};
2、下面开始定义指针指针类:
创建一个智能指针实例,执行构造函数,use为1,表示指向某个对象的指针初始化为1个;
当调用复制构造函数的时候,表示用右值对当前智能指针进行初始化,那么他们指向的是同一个对象,所以右值的use为加1,表示又多了一个指针指向此对象,之后左值与右值指向相同;
当调用赋值构造函数的时候,表示用右值覆盖当前左值智能指针,那么右值的use数加1,同时左值的use数减1,当为0时,释放左值指向的对象,之后左值与右值指向相同;
当执行析构函数时,每个智能指针析构一次,则指向的对象计数减1,当为0时,表示要释放对象。
template<class T>//定义模板类
class smartPointer
{
public:
smartPointer(T *p):pc(new count(1))
{
ptr = p;
cout << "gouzao use:" << pc->use << endl;
}
~smartPointer()
{
--pc->use;
cout << "xigou use:" << pc->use << endl;
if(pc->use == 0)
{//析构一次则指向相同指针的对象减1,当为0是,对所指指针进行删除
delete ptr;
delete pc;
}
}
smartPointer(smartPointer<T> &rhs)
{//复制构造函数
rhs.pc->use++;//指向的指针计数加1
pc = rhs.pc;
ptr = rhs.ptr;
cout << "copy use:" << pc->use << endl;
}
smartPointer<T> &operator = (smartPointer<T> &rhs)
{//赋值构造函数
if(this == &rhs)
return *this;
rhs.pc->use++;//指向的指针计数加1
if(--pc->use == 0)
{//原来的指针计数减1 ,如果为0,则删除
delete ptr;
delete pc;
};
ptr = rhs.ptr;
pc = rhs.pc;
cout << "assign use:" << pc->use << endl;
return *this;
}
private:
T *ptr;
count *pc;
};
3、下面开始举例,定义一个类point
class point
{
public:
point(int x):a(x)
{
p = new int(2);
}
~point()
{
delete p;
cout << "delete point p" << a << endl;
}
private:
int a;
int *p;
};
4、操作如下:代码里面没有delete,但是完成了对只针对象的内存管理。
int main()
{
point *p1 = new point(1);
point *p2 = new point(2);
smartPointer<point> ptr(p1);
smartPointer<point> ptr2(p2);
smartPointer<point> ptr3(ptr);
ptr2 = ptr;
return 0;
}
输出如下:
gouzao use:1
gouzao use:1
copy use:2
delete point p2
asign use:3
xigou use:2
xigou use:1
xigou use:0
delete point p1