#include
#include
using namespace std;
/*
好事多磨,本来今天不想抄这章代码,看下一章节的,但是,我想了想,小说不可能章章都精彩
*/
///业务处理类
class Point
{
public:
Point() :xval(0), yval(0){}
Point(int x, int y) : xval(x), yval(y){}
int x() const { return xval; }
int y() const { return yval; }
Point& x(int xv){ xval = xv; return *this; }
Point& y(int yv){ yval = yv; return *this; }
private:
int xval, yval;
};
///引用计数器类
class UseCount
{
public:
UseCount() : p(new int(1)){}
UseCount(const UseCount& u) :p(u.p)
{
++*p;
}
~UseCount()
{
if (--*p == 0)
{
delete p;
}
}
bool only()
{
return *p == 1;
}
bool reattach(const UseCount& u)
{
++*u.p;
if (--*p == 0)
{
delete p;
p = u.p;
return true;
}
p = u.p;
return false;
}
bool makeonly()
{
if (*p == 1)
{
return false;
}
--*p;
p = new int(1);
return true;
}
private:
UseCount& operator==(const UseCount&);
private:
int* p;
};
///句柄类,包含了业务处理类和一个引用计数器
///能够自动管理内存的诀窍:构造函数在创建对象的时候就给成员变量赋了初始值,比如给类Point类创建了内存,给UseCount赋初值
///在调用析构函数的时候去检查了下引用计数器是否等于1,如果等于1就释放掉类Point的内存
///这是C++语言的特性,C无法实现的功能
///这就是C++的奇妙之处,有始有终,在创建对象的时候,给你一个函数进行一些 *** 作,比如变量初始化,申请堆内存,在对象需要销毁的时候
///再给你一个函数进行一些 *** 作,比如销毁堆内存,释放其他资源
class Handle
{
public:
Handle() : p(new Point){}
Handle(int x, int y) :p(new Point(x, y)){}
Handle(const Point& p0) :p(new Point(p0)){}
Handle(const Handle& h) :u(h.u), p(h.p){}
~Handle()
{
if (u.only())
{
delete p;
}
}
Handle& operator=(const Handle& h)
{
if (u.reattach(h.u))
{
delete p;
}
p = h.p;
return *this;
}
int x() const
{
return p->x();
}
Handle& x(int x0)
{
if (u.makeonly())
{
p = new Point(*p);
}
p->x(x0);
return *this;
}
private:
Point* p;
UseCount u;
};
int main()
{
system("pause");
return 0;
}
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)