弱引用和循环引用

弱引用在许多编程语言中都相当有用，弱引用是相对强引用来说的，强引用是指你在某处使用了一个对象，在你释放这个引用前，这个对象是无法释放的，而弱引用则相反，虽然你拿着这个引用但是对象仍然可以释放，使用时也不保证对象有效。

在C++中有两个智能指针，shared_ptr针对强引用，每次构造必增加引用计数，weak_ptr针对弱引用，不增加引用计数，使用前要转换成shared_ptr才能使用。根据自己在实践中的经验，使用weak_ptr弱引用的场景有：

1. 比如有一个类引用另一个对象作为成员，但是又不想因为使用强引用，使得这个对象在外面无法释放，这时候刚好可以使用weak_ptr。

#include <memory>
#include <iostream>

using namespace std ;

class Entity {
public:
     Entity() {}
     ~Entity () {cout << ">> Entity Destructor" << endl ;}
};

class Contanier {
     weak_ptr< Entity> _entity ;
public:
     Contanier( shared_ptr< Entity> p ):_entity (p ) {}
     void Demo() {
            shared_ptr< Entity> realEntity = _entity .lock ();
            if (realEntity ) {
                 cout << "Entity Object still exist" << endl ;
            } else
                 cout << "Entity Object has been destroyed" << endl;
     }

};

int main (int argc, char *argv [])
{
     Contanier *container = NULL ;
     {
            shared_ptr< Entity> realEntity (new Entity());
            container = new Contanier( realEntity);
            container-> Demo();
     }
     container-> Demo();
           delete container;
      return 0
}


输出结果
Entity Object still exist             
 >> Entity Destructor                  
 Entity Object has been destroyed       
请按任意键继续. . .      

　　

2.第二个场景当然是防止循环引用了，循环引用指A拿着B的引用，B拿着A的引用，彼此无法释放，造成内存泄漏。如果彼此拿着的是对方的弱应用就不会出现这个问题了。看一个循环引用的C++代码：

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

class B;
class A {
public:
shared_ptr<B> _pB;

~A() { cout << ">> ~A() << " << endl; }
};
class B {
public:
shared_ptr<A> _pA;

~B() { cout << ">> ~B() << " << endl; }
};

void Run() {
shared_ptr<A> pA(new A);
shared_ptr<B> pB(new B);
pA->_pB = pB;
pB->_pA = pA;
}

int main(int argc, char *argv[]) {
Run();
cout << "over" << endl;
return 0;
}

输出 over.

可见Run结束后并没有成功释放A,B对象。

　　

3.lua中的弱表

lua里面也有弱引用，虽然lua的垃圾收集器可以保证没有循环引用的问题，但是lua引用在内存泄漏方面还是有重要意义，在工作实践中，lua的弱引用table（weak table）常被用来检测内存泄漏问题，因为是弱引用并不阻止GC，把要监测的对象放入weak table中，过一段时间，该对象本该要释放，但是在weak table中仍然能检索到此对象，表示此对象泄漏了。演示代码如下：

MemLeakChecker = {}

setmetatable(MemLeakChecker, {__mode="v"})

local Obj = {["Name"] = "Obj1"}

MemLeakChecker["obj1"] = Obj

function DestroyObj()

     Obj = nil

end

DestroyObj()

assert(not MemLeakChecker["obj1"])

 代码其实没有更好的演示出内存泄漏检测的功能，看起来Obj在这里很难泄漏，但是在真正的工作代码中，lua工程常常有成千上万行代码，不同模块有意或无意的引用了一些全局变量，使得GC无法释放，运行久了后，内存消耗巨大，这时使用weak table实时检测跟踪内存泄漏就相当有意义了。                                                                            

转载于:https://www.cnblogs.com/persistentsnail/archive/2013/04/04/3294845.html