句柄类定义(1、一般定义 2、理解实质)

句柄类涉及的技术(1、引入使用计数 2、使用计数类 3、写时复制)

句柄类的实例(1、完成源码程序 2、运行结果分析)

与句柄类相关的类

句柄类例子

句柄类定义

1、一般定义

句柄类（智能指针smart point）是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。

在C++中一个通用的技术是定义包装（cover）类或句柄（handle）类，也称智能指针。句柄类存储和管理基类指针。指针所指向对象的类型可以变化，它既可以指向基类类型对象又可以指向派生类型对象。用户通过句柄类访问继承层次的操作。因为句柄类使用zi指针执行操作，虚成员的行为将在运行时根据句柄实际绑定的对象类型而变化，即实现c++运行时动态绑定。故句柄用户可以获得动态行为但无需操心指针的管理。

2、理解实质

句柄类实际上通过复制指向引用计数器类型的指针，来代替复制实际对象；从而使得复制对象变成复制指针，实现虚拟复制（即是用复制对象的地址代替复制对象本身），以提高内存效率和访问速度。在涉及到大型、复杂对象以及一些不能复制或是不易复制的对象的复制控制问题时，显得特别有用。

句柄类涉及的技术

1、引入使用计数

定义句柄类或智能指针的通用技术是采用一个使用计数（use count）。句柄类将一个计数器与类指向的对象相关联。使用计数跟踪该类有多少个指针共享同一对象。当使用计数为0时，就删除该类对象，否则再删除类对象时，只要引用计数不为0，就不删除实际的类对象，而是是引用计数减1，实现虚删除。

2、使用计数类

为了便于理解，我们定义一个实际类（Point），一个引用计数器类（UPoint），一个句柄类（Handle），后面将有例子给以参考。

实现使用计数有两种经典策略：一种是定义一个单独的具体的类用以封装使用计数和指向实际类的指针；

另一种是定义一个单独的具体的类用以封装引用计数和类的对象成员。我们称这种类为计数器类（UPoint）。在计数器类中，所有成员均设置为private，避免外部访问，但是将句柄类Handle类声明为自己的友元，从而使句柄类能操纵引用计数器。

3、写时复制

写时复制（copy on write）技术是解决如何保证要改动的那个引用计数器类UPoint对象不能同时被任何其他的句柄类（Handle类）所引用。通俗的来说，就是当实际对象Point被多个Handle类的指针共享时，如果需要通过指针改变实际对象Point，而其他的指针又需要保持原来的值时，这就有矛盾了。打个不恰当的比方来说，两个以上的人共有5W块钱，如果其中一个人想用这5W块钱去消费，那就必须通知其他人。否则在这个人消费了5块钱后，其他人还以为他们仍然有5W块钱，如果这儿时候，他们去买5W的东西，就会发现钱变少了或是没有了，此时他们就陷入债务的泥团。在C++中通过指针访问已经删除或是不存在的对象，将是非常危险的。有可能系统提示该行为未定义，也有可以内存非法访问，还有可能使系统崩溃。

句柄类的实例

1、完成源码程序

#include <iostream>

using namespace std;

// 句柄类中封装的实际对象类型；Point；

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; }

~Point()

{

cout << "~Point!" << endl; //测试时用于分析对象的析构过程；

}

protected:

private:

int xval;

int yval;

};

//引用类型计算器类；

class UPoint

{

//所有的数据成员和函数成员均为：private类型；

friend class Handle; //将句柄类声明为友元类，便于访问引用计数器；

Point p; //声明一个Point实际对象的数据类型；实现数据隐藏；

int u; //引用计数器；

//当创建一个handle句柄对象时，将通过引用计数类自动创建一个Point的真实对象；

//同时使计数器 U 自动为1；

UPoint():u(1) {}

UPoint(int x, int y) : p(x, y), u(1) {}

UPoint (const Point & p0): p(p0), u(1) {}

~UPoint()

{

cout << "~UPoint!" << endl; //测试时用于分析对象的析构过程；

}

};

//句柄类实际上通过复制指向引用计数器类型的指针，来代替复制实际对象；从而使得

//复制对象变成复制指针，提高内存效率和访问速度；

class Handle

{

public:

//句柄类的构造函数，主要通过复制句柄中指向基类的指针来实现对象复制的虚拟操作；

//3个构造函数；

Handle(): up(new UPoint) {}

Handle(int x, int y): up(new UPoint(x,y)) {}

Handle(const Point &p): up(new UPoint(p)) {}

//复制函数；使引用计数自动加 1；

Handle(const Handle &h ) : up(h.up) {++up->u;}

//赋值函数；使赋值右侧对象的引用计数自动加 1；

Handle& operator= (const Handle &h)

{

++h.up->u; //赋值右侧引用计数器加 1；

//如果up的引用计数器为1，就直接删除up所指向的对象；

//经验，任何改变实际引用计数器状态变化的操作都应该检查引用计算器

//是否为 0 ，为0就应该删除实际操作对象；

if (--up->u == 0)

delete up;

up = h.up;

return *this; //返回修改指针up地址值的自身兑现引用；

}

~Handle()

{

//如果 up 所指的对象 引用计数为 u 为最后一个，则应该删除对象；

if (--up->u == 0)

delete up;

cout << "~Handle!" << endl;

}

int x() const

{

return up->p.x();

}

Handle & x(int x0) //采用句柄的值语义；

{

//更改up对象的值时，当引用计数不为 1时，则说明实际对象point 关联多个

//handle的 up指针，为了保持原来指针所指向对象的数据不被改变；此时

//需要 将该对象的引用计数 减 1， 然后重新定义一个新引用计数器类型；

if (up->u != 1)

{

//将原对象的引用计数 减 1；再申请一个引用计数器对象；

//采用写时复制技术解决更改Point对象时所带来的问题；

--up->u;

up = new UPoint(up->p);

}

up->p.x(x0);

return *this;

}

int y() const

{

return up->p.y();

}

Handle & y(int y0)

{

if (up->u != 1)

{

--up->u;

up = new UPoint(up->p);

}

up->p.y(y0);

return *this;

}

// protected:

private:

UPoint *up;

};

int main(int argc, char *argv[])

{

Handle h(23, 34), tmp(h); //定义句柄对象h，和tmp

Handle val; //定义默认的句柄类对象；

//通过句柄类执行实际类Point 成员函数功能；

cout << "handle::h " << h.x() << '\\t' << h.y() << endl;

cout << "handle::tmp " << tmp.x() << '\\t' << tmp.y() << endl;

cout << "handle::val "<< val.x() << '\\t' << val.y() << endl;

//关键的一步val = h；将涉及写时复制；因为h和tmp指针共享同一指针；

val = h.x(100); //改变句柄类h所指对象point对象x的值后赋值给val句柄；

cout << "handle::h " << h.x() << '\\t' << h.y() << endl;

cout << "handle::tmp " << tmp.x() << '\\t' << tmp.y() << endl;

cout << "handle::val "<< val.x() << '\\t' << val.y() << endl;

return 0;

}

2、运行结果分析

handle::h 23 34

handle::tmp 23 34 //h和tmp句柄类对象实际共享同一Point（23，34）对象；

handle::val 0 0 //val默认指向实际对象Point（0，0）；

~UPoint! //由于写时复制时：up = new UPoint(up->p);创建了一个临时UPoint

~Point! //对象；调用完后释放，由于Point是UPoint的成员对象，所以先

//UPoint，然后是Point。

handle::h 100 34 //通过修改赋值val = h.x(100);后，h和val共享同一对象Point（100，34）

handle::tmp 23 34

handle::val 100 34

//依次释放内存；

~Handle! //val句柄类对象；val(100，34)

~UPoint!

~Point!

~Handle! //tmp句柄类；tmp(23,34)

~UPoint!

~Point!

~Handle! //只释放了一个句柄类Handle的指针，没有实际对象；

请按任意键继续. . .

与句柄类相关的类

代理（surrogate）类，又称委托。（后续完善）

这篇关于句柄类的介绍，在理论部分还是挺不错的，但举的例子就不敢恭维了，UPoint类的目的是从Handle类中将“引用计数”功能分离出来单独实现，让Handle类专注于实现“内存管理”功能，因此UPoint类必须能够实现自动计数，而不应该在Handle类中再来对其加减。

上面分析结果的最后一段：

~Handle! //val句柄类对象；val(100，34)　~UPoint!　~Point!　~Handle! //tmp句柄类；tmp(23,34)　~UPoint!　~Point!　~Handle! //只释放了一个句柄类Handle的指针，没有实际对象；　请按任意键继续. . .

分析有误，改为：

~Handle! //val句柄类对象；val(100，34)

~UPoint! //temp指向的UPoint对象

~Point! //temp指向的UPoint对象的内嵌Point对象

~Handle! //tmp句柄类；tmp(23,34)

~UPoint! //val和h共同指向的Upoint对象

~Point! //val和h共同指向的Upoint对象的内嵌对象Point

~Handle! //释放h句柄类

句柄类例子

#include <iostream>

using namespace std;

//-----------------------------------------

class Point

{

private:

int xval,yval;

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;}

};

//------------------------------------------------------

class UseCount

{

private:

int* p;

UseCount& operator=(const UseCount&);

public:

UseCount();

UseCount(const UseCount&);

~UseCount();

bool only();

bool reattach(const UseCount&);

bool make_only();

};

UseCount::UseCount():p(new int(1)){}

UseCount::UseCount(const UseCount&u):p(u.p){++*p;}

UseCount::~UseCount()

{

if (--*p==0)

{

delete p;

}

}

bool UseCount::only()

{

return *p==1;

}

bool UseCount::reattach(const UseCount& u)

{

++*u.p;

if (--*p==0)

{

delete p;

p=u.p;

return true;

}

p=u.p;

return false;

}

bool UseCount::make_only()

{

if (*p==1)return false;

--*p;

p=new int(1);

return true;

}

//-------------------------------------------

class Handle

{

private:

Point* p;

UseCount u;

public:

Handle();

Handle(int,int);

Handle(const Point&);

Handle(const Handle&);

Handle& operator =(const Handle&);

~Handle();

int x()const;

Handle&x(int);

int y()const;

Handle&y(int);

};

Handle::Handle():p(new Point){}

Handle::Handle(int x,int y):p(new Point(x,y)){}

Handle::Handle(const Point&p0):p(new Point(p0)){}

Handle::Handle(const Handle&h):u(h.u),p(h.p){}

Handle::~Handle()

{

if (u.only())

{

delete p;

}

}

Handle& Handle::operator=(const Handle &h)

{

if (u.reattach(h.u))delete p;

p=h.p;

return *this;

}

int Handle::x()const

{

return p->x();

}

int Handle::y()const

{

return p->y();

}

Handle& Handle::x(int x0)

{

if (u.make_only())p=new Point(*p);

p->x(x0);

return *this;

}

Handle& Handle::y(int y0)

{

if (u.make_only())p=new Point(*p);

{

p->y(y0);

return *this;

}

}

//---------------------------------------------------

int main()

{

Handle h(3,4);

Handle h2 = h;

h2.x(5);

int n = h.x();

cout<<n<<endl;

return 0;

}