码迷,mamicode.com
首页 > 编程语言 > 详细

c++智能指针以及循环引用问题(转)

时间:2015-05-27 22:39:10      阅读:597      评论:0      收藏:0      [点我收藏+]

标签:

解决循环引用:

     在知道存在循环引用的条件下,使用boost::weak_ptr,即弱引用来代替循环引用中的某个强引用,从而打破循环引用的环


由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete,比如流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见,并造成内存泄露。如此c++引入 智能指针 。

c++ 智能指针主要包括:unique_ptr,shared_ptr, weak_ptr, 这三种,其中auto_ptr 已被遗弃。 

unique_ptr  如下代码所示:

class A;
// 如果程序执行过程中抛出了异常,unique_ptr就会释放它所指向的对象
// 传统的new 则不行
unique_ptr<A> fun1()
{  unique_ptr p(new A);
  //do something  return p;
}

void fun2()
{   //unique_ptr具有移动语义  unique_ptr<A> p = f();// 使用移动构造函数  // do something
}   //在函数退出的时候,p以及它所指向的对象都被删除释放
 shared_ptr 
采用引用计数的智能指针。 shared_ptr基于“引用计数”模型实现,多个shared_ptr可指向同一个动态对象,并维护了一个共享的引用计数器,记录了引用同一对象的shared_ptr实例的数量。当最后一个指向动态对象的shared_ptr销毁时,会自动销毁其所指对象(通过delete操作符)。shared_ptr的默认能力是管理动态内存,但支持自定义的Deleter以实现个性化的资源释放动作。头文件:<memory>。 

基本操作:shared_ptr的创建、拷贝、绑定对象的变更(reset)、shared_ptr的销毁(手动赋值为nullptr或离开作用域)、指定deleter等操作。

shared_ptr的创建,有两种方式:

一,使用函数make_shared(会根据传递的参数调用动态对象的构造函数);

二,使用构造函数(可从原生指针、unique_ptr、另一个shared_ptr创建) 

    shared_ptr<int> p1 = make_shared<int>(1);// 通过make_shared函数
    shared_ptr<int> p2(new int(2));// 通过原生指针构造
此外智能指针若为“空“,即不指向任何对象,则为false,否则为true,可作为条件判断。可以通过两种方式指定deleter,一是构造shared_ptr时,二是使用reset方法时。可以重载的operator->, operator *,以及其他辅助操作如unique()、use_count(), get()等成员方法。 

 weak_ptr 

结合 shared_ptr 使用的特例智能指针。 weak_ptr 提供对一个或多个 shared_ptr 实例所属对象的访问,但是,不参与引用计数。 如果您想要观察对象但不需要其保持活动状态,请使用该实例。 在某些情况下需要断开 shared_ptr 实例间的循环引用。 头文件:<memory>。 

weak_ptr的用法如下:

weak_ptr用于配合shared_ptr使用,并不影响动态对象的生命周期,即其存在与否并不影响对象的引用计数器。weak_ptr并没有重载operator->和operator *操作符,因此不可直接通过weak_ptr使用对象。提供了expired()与lock()成员函数,前者用于判断weak_ptr指向的对象是否已被销毁,后者返回其所指对象的shared_ptr智能指针(对象销毁时返回”空“shared_ptr)。循环引用的场景:如二叉树中父节点与子节点的循环引用,容器与元素之间的循环引用等。 

智能指针的循环引用

循环引用问题可以参考 这个链接 上的问题理解,“循环引用”简单来说就是:两个对象互相使用一个shared_ptr成员变量指向对方的会造成循环引用。导致引用计数失效。下面给段代码来说明循环引用:

#include <iostream>#include <memory>using namespace std;

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public  //weak_ptr<B> pb;  shared_ptr<B> pb;
  void doSomthing()
  {
//		if(pb.lock())//		{////		}  }

  ~A()
  {
    cout << "kill A\n";
  }
};

class B
{
public:
  //weak_ptr<A> pa;  shared_ptr<A> pa;
  ~B()
  {
    cout <<"kill B\n";
  }
};

int main(int argc, char** argv)
{
  shared_ptr<A> sa(new A());
  shared_ptr<B> sb(new B());
  if(sa && sb)
  {
    sa->pb=sb;
    sb->pa=sa;
  }
  cout<<"sa use count:"<<sa.use_count()<<endl;
  return 0;
}
上面的代码运行结果为:sa use count:2, 注意此时sa,sb都没有释放,产生了内存泄露问题!!!

即A内部有指向B,B内部有指向A,这样对于A,B必定是在A析构后B才析构,对于B,A必定是在B析构后才析构A,这就是循环引用问题,违反常规,导致内存泄露。

一般来讲,解除这种循环引用有下面有三种可行的方法( 参考 ): 
1 . 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。 
2 . 当A的生存期超过B的生存期的时候,B改为使用一个普通指针指向A。 
3 . 使用弱引用的智能指针打破这种循环引用。 
虽然这三种方法都可行,但方法1和方法2都需要程序员手动控制,麻烦且容易出错。我们一般使用第三种方法:弱引用的智能指针weak_ptr。 

强引用和弱引用 
一个强引用当被引用的对象活着的话,这个引用也存在(就是说,当至少有一个强引用,那么这个对象就不能被释放)。share_ptr就是强引用。相对而言,弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数,这意味这弱引用它并不对对象的内存进行管理,在功能上类似于普通指针,然而一个比较大的区别是,弱引用能检测到所管理的对象是否已经被释放,从而避免访问非法内存。 

使用weak_ptr来打破循环引用 

代码如下:

#include <iostream>#include <memory>using namespace std;

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public  weak_ptr<B> pb;
  //shared_ptr<B> pb;  void doSomthing()
  {
    if(pb.lock())
    {

    }
  }

  ~A()
  {
    cout << "kill A\n";
  }
};

class B
{
public:
  //weak_ptr<A> pa;  shared_ptr<A> pa;
  ~B()
  {
    cout <<"kill B\n";
  }
};

int main(int argc, char** argv)
{
  shared_ptr<A> sa(new A());
  shared_ptr<B> sb(new B());
  if(sa && sb)
  {
    sa->pb=sb;
    sb->pa=sa;
  }
  cout<<"sb use count:"<<sb.use_count()<<endl;
  return 0;
}

 




c++智能指针以及循环引用问题(转)

标签:

原文地址:http://www.cnblogs.com/ZhangJinkun/p/4534545.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!