智能指针(OSG源码摘录)

智能指针只是对指针添加引一个引用计数(_refCount).当new一个对象(即将对象赋予

ref_ptr<>变量)时_refCount加1.将ref_ptr<>变量指向其它的对象或者将其释放(超出其

生命范围,如局部变量)时,执行Referenced::unref(),_refCount会减1,此时如果

_refCount为0表明此对象已经没有引用,可删除,delete this;会调用析构函数

~Referenced(),并释放内存资源.

template<class T>

class ref_ptr

{

public:

typedef T element_type;

ref_ptr() : _ptr(0) {}

ref_ptr(T* ptr) : _ptr(ptr) { if (_ptr) _ptr->ref(); }//构造函数2

inline ref_ptr& operator = (T* ptr)

{

if (_ptr==ptr) return *this;

T* tmp_ptr = _ptr;

_ptr = ptr;

if (_ptr) _ptr->ref();//添加新进的

// unref second to prevent any deletion of any object which might

// be referenced by the other object. i.e rp is child of the

// original _ptr.

if (tmp_ptr) tmp_ptr->unref();//释放原来的

return *this;

}

T* get() const { return _ptr; }

T& operator*() const { return *_ptr; }

T* operator->() const { return _ptr; } //指针重载

T* _ptr;//类数据成员

};

void Referenced::unref()

{

...

if ( ...)

{

delete this;//会调用析构函数~Referenced(),并释放内存空间

}

}

调用时:

osg::ref_ptr< osg::Group > root= new osg::Group();//新建对象,调用ref_ptr的操作

符重载函数ref_ptr& operator = (T* ptr),并将其转化为指针指向的值. 此时内存中

Group的引用计数为1.

root.get();//智能指针的成员函数

osg::ref_ptr< osg::Geode > g= new osg::Geode();//内存中Geode的引用计数为1.

osg::ref_ptr< osg::Node > g= new osg::Geode();//ref_ptr的=操作符重载(添加新进

的,释放原来的),上一行中的Geode的引用计数变减1,变为0,此行中新建的Node的引用计数

加1,变为1.

root->addChild( g);//智能指针指向的值的函数.此时Node的引用计数加1,变为2,因为引

用它的对象又多了一个(root).

------------------------------------------------------------

下面是一个.和->操作符两种符号能同时使用的例子:

template<class T>

class ref_ptr

{

public:

ref_ptr(T* ptr) : _ptr(ptr) { }//构造函数

T* operator->() const { return _ptr; } //指针重载

T* get() const { return _ptr; }

protected:

T* _ptr;//类数据成员

};

class CA

{

public:

void Fun()

{

cout<< "tm\n";

}

};

class CA

{

public:

void Fun()

{

cout<< "tm\n";

}

};

int _tmain(int argc, _TCHAR* argv[])

{

ref_ptr< CA> pi( new CA);

pi.get();//对象本身就有.操作符

pi->Fun();//重载的指针操作符,如果ref_ptr类中不对指针操作符进行重载,则

会报错.pi->后直接接T的成员函数,不能是pi->()或pi->()->Fun()等.

}

＝＝＝＝＝＝＝＝＝＝＝

附：指针操作符（->）重载：

重载operator->()，返回普通对象指针，称为间接(Dereferencing)，可形成“智能指针

”机制（即对象->函数()，如C c; c->Fun()，这需要C类对指针操作符进行重载）。这样

方便操作，也可不用。对于obj->member;，operator ->为一元后缀运符，可作两种解释

：

①如obj为指针，将寻找紧随其后的类成员(或函数)标识符，找不到就出错，这也是最常

见的用法。

②如obj为（定义的智能指针）对象，将解释为(obj.operator->())->member。若obj类未

重载operator->()则出错；当重载了X operator ->()时，如果返回类型X为指针，则进入

①状态；如果返回值类型仍为对象，再进入②状态，判断是否可循环。

返回值应该为两种：①指针，并找到成员标志符；②定义了operator->()的对象，将循环

迭代。否则出错。

具体示例见于《C++ Primer》14.6节与《C++ Programming Language》11.10章节。

如上面代码中的pi->Fun();即相当于是(pi.operator->())->Fun()。