智能指针

来源:互联网 发布:好莱客整体衣柜 知乎 编辑:程序博客网 时间:2024/03/29 02:02

 

摘自:Don Burns《Using Reference Pointers in Producer and OpenSceneGraph》

ref_ptr
<> 利用引用计数管理分配在堆上的内存,计数为(0)时自动释放内存

规则1:
对所有从Referenced 继承的类,都用ref_ptr
<>
规则2:
绝对不要返回ref_ptr
<> 指向的地址,返回ref_ptr<> 它自己
规则3:
绝对不要用ref()、unref(),(或者release()、unref_nodelete())除非你真的真的真的知道你在干什么
规则4:
任何Referenced 的派生类(无论直接或间接),析构函数都要设为protected,使对象不会被分配到栈上
规则5(规则1的例外):
循环引用时,当我们知道此对象在当前范围内会被另外的ref_ptr 引用,就有必要(小心地)使用简单指针

==================================

首先弄清楚:

1、分配在堆(heap)上的内存是指调用 new() 或者 malloc() 之类的方法动态分配的那些,需要由程序员自己负责跟踪和回收(delete、free),否则会引起内存泄漏;分配在栈(stack)上的内存由编译器管理,不用我们操心,比如局部变量。

2、引用计数(reference count)是用来管理分配在堆上的对象的。若有个外部实体需要用到这个对象,引用计数+1,用完则-1,当减为0时对象就释放它自己。

===============================

下面看 ref_ptr
<>

  ref_ptr
<>是模版类,可以实例化为指向任何从Referenced继承的对象指针。严格地说,ref_ptr<>自身是分配在栈上的,但是保存的是分配在堆上的内存的地址。它的作用就是实现自动引用计数:ref_ptr<>所指对象的引用计数在复制构造函数或者"="操作符时 +1,在析构函数里 -1

  现在比较一下:

void SomeClass::someMethod()
{
    osg::ref_ptr nodeRefPtr 
= new osg::Node;
    osg::Node 
*nodePtr = new osg::Node;
}


  上面的函数返回时,nodeRefPtr 调用其析构函数,对象的引用计数减为(
0),对象自动释放它自己;而nodePtr 在函数外无效,它原来指向的内存仍然留在堆里,而且无法跟踪。

  再看这个例子:

void SomeClass::someMethod(osg::Group *group)
{
    osg::ref_ptr nodeRefPtr 
= new osg::Node;
    group
->addChild( nodeRefPtr.get() );
}


  函数中group的ref_ptr
<>使对象的引用计数增为(2),当函数返回时,nodeRefPtr 析构使对象的计数减为(1),所以当group还在使用此对象时它不会释放自己。对于.get(),暂时可以理解为返回osg::Node对象的地址。

  一般用 
bool valid() 来判断智能指针是否指向有效的地址。

=============================

需要注意的几点:

1、混用 * 和 ref_ptr<>

  看下面这段代码,doSomethingWithNode 函数利用ref_ptr
<>将对象的引用计数增为(1),函数返回时又减为(0),此时对象释放自己占用的内存。当doSomeStuff()再对那块内存操作时就会出错。

void SomeClass::doSomethingWithNode( osg::Node *node )
{
    osg::ref_ptr nPtr 
= node;
    nPtr
->doit();
}

void SomeClass::doSomeStuff()
{
    osg::Node 
*node = new osg::Node;
    doSomethingWithNode( node );
    node
->doitAgain();    // node 现在指向已经删除的数据,引起access violation
}


规则1:
对所有从Referenced 继承的类,都用ref_ptr
<>

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

2、用ref_ptr<> 作函数返回值

  下面的代码中,createANode()动态分配的内存在它退出时就已经释放,initializeOrSomething()无法在释放之前增加引用计数。

void SomeClass::initializeOrSomething()
{
    osg::ref_ptr nodeRefPtr 
= createANode();
}

osg::Node 
*SomeClass::createANode()
{
    
// 按照规则1
    osg::ref_ptr nRefPtr = new osg::Node;
    
return nRefPtr.get();  // 指向的内存会在函数退出时释放
}


  有两个方法解决:
  
1)createANode()中不用ref_ptr<>,可能造成内存泄漏;
  
2)手动增加计数nRefPtr->ref(),还需要自己调用unref()

  所以最好还是将ref_ptr
<>作为返回值:

osg::ref_ptr SomeClass::createANode()
{
    osg::ref_ptr nRefPtr 
= new osg::Node;
    
return nRefPtr; // OK!
}


规则2:
绝对不要返回ref_ptr
<> 指向的地址,返回ref_ptr<> 它自己
规则3:
绝对不要用ref()、unref(),(或者release()、unref_nodelete())除非你真的真的真的知道你在干什么

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

3、不适当地应用从Referenced 继承的对象

  osg 和Producer 的基类把它们的析构函数定义为protected,强制用户将这些类分配在堆上而不是栈上。但是,下面定义的MyNode 却是合法的,它的析构函数设为public。这样程序员可以合法(但是不适当)地将这个类作为局部变量放在栈上,这时如果有个ref_ptr
<> 引用它,就会使引用计数减为(0),导致栈变量试图删除它自己。

class MyNode : public osg::Node
{
public:
    MyNode() 
{}
    
virtual ~MyNode() {} // public destructor
}

void someClass::doSomething()
{
    MyNode myNode;
    DoSomethingWithMyNode( 
&myNode );
}

void someClass::doSomethingWithMyNode( MyNode *n)
{
    osg::ref_ptr mnRefPtr 
= n;
}


规则4:
任何Referenced 的派生类(无论直接或间接),析构函数都要设为protected,使对象不会被分配到栈上

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

4、循环引用

  当两个从Referenced 继承的类实例互相引用对方时,就可能造成循环引用。

class B;

class A : public osg::Referenced
{
public:
    A() 
{}
    
void setB(B *b);
private:
    osg::ref_ptr _b;
}
;

class B : public osg::Referenced
{
public:
    B(A 
*a) : _a(a) {}
private:
    osg::ref_ptr _a;
}
;

void A::setB( B *b) { _b=b; }

int main()
{
    osg::ref_ptr a 
= new A;  //(a's count is 1)
    osg::ref_ptr b = new B(a.get());  //(b's count is 1 and a's count is 2)
    a->setB(b.get());  //(b's count is 2)
    return 0;
}

// a 和 b 在这里失效,引用计数各-1,变为(1),对象没有删除

解决方法是利用简单指针:

class B;

class A : public osg::Referenced
{
public:
    A(): _b(
0L{}
    
void setB(B *b);
private:
    
// Not a ref pointer
    B *_b;
}
;

class B : public osg::Referenced
{
public:
    B(A 
*a) : _a(a) {}
private:
    
// Not a ref pointer
    A *_a;
}
;

void A::setB( B *b) { _b=b; }

int main()
{
    osg::ref_ptr a 
= new A;  // &a's count is 1
    osg::ref_ptr b = new B(a.get());  // &b's count is 1 and &a's count remains 1
    a->setB(b.get());  // &b's count remains 1
    return 0;
}

// a and b go out of scope, counts go to 0

规则5(规则1的例外):
循环引用时,当我们知道此对象在当前范围内会被另外的ref_ptr 引用,就有必要(小心地)使用简单指针
原创粉丝点击