在java 和 c# 中都有垃圾回收功能，程序员在分配一段内存后可以不再理会，而由垃圾回收自动回收，从而使程序员从复杂的内存管理中解脱出来。这是java 和 c#的一大优点。而c++程序员在用 new 分配了一段内存后，还必须用 delete 释放，否则将造成资源泄漏。因此，一些c++ 书上经常告诫程序员：要养成好的习惯，new 与 delete 要成对出现，时刻记住将内存释放回系统。但是，事情只是这么简单吗？
    经常地，在使用c++的过程中，我们会遇到下面的情形：
        class  a
             {
                public：
              a（）；
              ~a（）；
              setnextptr（a* ptr）
                   {pnext=ptr；}
               
               private：
              a *   pnext；
              }
       一般地，为了不引起内存泄漏，我们会在析构函数中释放pnext，象下面这样：
        a：：~a（）
        {
          if（pnext）
            delete pnext；
                  pnext=null;
        }
    对于一般情况，这样就够了，但在某些情形下，这样也会出问题的，象下面这样：
        a  *ptrb  =  new a;；
        a *ptra = new a；
        ptrb->setnextptr(ptra);
        ptra->setnextptr(ptrb);
         
            delete  ptrb;   
    这样会出问题,因为这些指针连成了一个回环,无论从那一个点开始删除,都会造成一个指针被删除两次以上,这将使得程序抛出异常。当然，也有一些方法可以用来解决这个问题，但是我要说明的是：对于c++程序员来说，养成一个好的习惯并不难，难就难在有时候这样将把你带入一种逻辑的混乱当中 ，增加一些不必要的麻烦，有时甚至不知所措。
    可是如何解决这个问题呢？如果c++也具有垃圾回收的功能，那么，这个问题当然就迎刃而解了。但是c++属于编译型语言，不会具备这个功能。长期以来，我也一直在思考这个问题，想找出一种方法来使自己从这种麻烦中解脱出来。直到最近开始学习泛型编程，看到灵巧指针的介绍以后，我灵光一闪，终于找到了办法来解决这个问题。
    大家知道，灵巧指针具有一些灵巧特性，如在构造时可以自动初始化，析构时可以自动释放所指的指针。我们就利用它的这些特性来实现我们的垃圾回收。
    首先，我们要想办法来对我们用 new 分配的每一段内存增加引用记数，即记录下当前指向它的灵巧指针个数，当最后一个指向它的指针被释放时，我们就可以释放这段内存了。由此，我们进行了new 和 delete 的全局重载，并引入了cptrmanager 类。

void operator delete(void * p)
{
 
 int mark=theptrmanager.getmarkfromptr(p);
 if(mark>0)
     theptrmanager.userdelete(mark);
 free(p);
}
void * operator new(size_t size)
{

  
  return theptrmanager.mallocptr(size);

}
class cptrmanager 
{
public:
 int getcount(int mark,void * p);  file://得到当前的引用记数
 static cptrmanager* getptrmanager(); file://得到全局唯一的cptrmanager 指针
 void userdelete(int mark);  file://删除 mark 标志的指针，并对指针和标志复位
 void * mallocptr(size_t size); file://new（）调用它分配内存；
 bool addcount(int mark,void * ptr); file://增加引用记数
 bool release(int mark,void * ptr); file://减少引用记数
 int getmarkfromptr(void * ptr);  file://通过指针得到标志
 cptrmanager();
 virtual ~cptrmanager();
private:
 static cptrmanager * p_this;  file://指向全局唯一的cptrmanager 指针
 void addptr(void * ptr);  file://增加一个新分配的内存
           cptrarray  m_ptr;   file://存放分配的指针的可变数组
 cuintarray m_count; file://存放指针的引用记数
 void*  pcurrent;   file://最近刚分配的指针
 unsigned int m_mark; file://最近刚分配的指针的标志
 cuintarray m_removed;//存放m_ptr中指针被删除后所空留的位置
};
    顾名思义，cptrmanager 就是用来管理指针的，对于我们用new 分配的每一个指针，都存放在m_ptr[index]中，并在m_count[index]中存放它的引用记数。同时，我们对每一个指针都增加了一个标志（mark >0,<=0为无效），这个标志同时存在于灵巧指针中（后面将看到），这是为了一种双重保险，并且在这里，这个标志就等于指针在m_ptr中的索引，这也为快速查找提供了方便。
    总的思路是这样的：当我们用new分配一个指针时，这个指针将被存入cptrmanager中，当一个灵巧指针开始拥有这个指针时，cptrmanager将负责对这个指针的引用记数加 1 ，反之亦然，即一个灵巧指针开始释放该指针的拥有权时，cptrmanager将负责对这个指针的引用记数减 1 ，如果引用记数为 0 ，那么这个灵巧指针将负责对该指针 delete。
    下面是灵巧指针的部分介绍：
template
class auto_ptr
{
   public:
    auto_ptr()
    {mark=0;pointee=0;}
    auto_ptr(auto_ptr&rhs);
    auto_ptr(t*ptr);
    ~auto_ptr(){remove();}
    t*operator->() const;
    operator t*();
    t&operator*()const;
    auto_ptr&operator=(auto_ptr&rhs);
       auto_ptr&operator=(t*ptr);
   private:
              void remove(); file://释放所指指针的拥有权
    t*pointee;  file://所拥有的指针
    int mark;//所拥有的指针的标志
};
template void auto_ptr< t>::remove()
{
       cptrmanager * pmana=cptrmanager::getptrmanager();
 if(pointee&&pmana)
 {
   if(pmana->release(mark,pointee))   file://减少引用记数
   {
        if(pmana->getcount(mark,pointee) ==0)
         delete pointee;    file://如果引用记数为0，delete 指针
   }     
   else  file://所拥有的指针不在cptrmanager 中，有可能在栈中
   {
    file://user decide to do
   }

 }
 pointee=null;  file://复位
 mark=0;
}
template auto_ptr< t>::auto_ptr(auto_ptr&rhs)
{
 pointee=rhs.pointee;
 mark=rhs.mark;
 cptrmanager * pmana=cptrmanager::getptrmanager();
 if(pmana)
    pmana->addcount(mark,pointee); file://增加引用记数
 
}
template auto_ptr< t>::auto_ptr(t*ptr)
{
       mark=0;
       pointee=ptr;
       cptrmanager * pmana=cptrmanager::getptrmanager();
       if(pmana)
    {
       mark=pmana->getmarkfromptr(ptr); file://得到指针的标志
       if(mark>0)
           pmana->addcount(mark,pointee);  file://如果标志不为0，增加引用记数
    }
}
templateauto_ptr& auto_ptr< t>::operator=(auto_ptr&rhs)
{
 if(pointee!=rhs.pointee)
 {
     remove();  file://释放当前指针的拥有权
     pointee=rhs.pointee;
     mark=rhs.mark;
     cptrmanager * pmana=cptrmanager::getptrmanager();
     if(pmana)
        pmana->addcount(mark,pointee);

 }
 return *this;

}
template auto_ptr&auto_ptr< t>::operator = (t* ptr)
{
   if(pointee!=ptr)
   {
       remove();
       pointee=ptr;
       cptrmanager * pmana=cptrmanager::getptrmanager();
       if(pmana)
       {
          mark=pmana->getmarkfromptr(ptr);
          if(mark>0)
    pmana->addcount(mark,pointee);
       }
   }

}
   当到了这里时，我便以为大功告成，忍不住摸拳搽掌，很想试一试。结果发现对于一般的情况，效果确实不错，达到了垃圾回收的效果。如下面的应用：
    auto_ptr p1=new  test;
       auto_ptrp2 = p1;
       auto_ptrp3 = new test;
    但是，很快地，我在测试前面提到的回环时，就发现了问题，我是这样测试的：
    class test
            {
 auto_ptr p;
            };

       auto_ptr p1=new test;
       auto_ptrp2 =new test;
       p1->p=p2;
       p2->p=p1;
      当程序执行离开作用域后，这两块内存并没有象我想象的那样被释放，而是一直保留在堆中，直到程序结束。我仔细分析造成这种现象的原因，发现了一个非常有趣的问题，我把它称之为互锁现象。
   上面p1 所拥有的指针被两个灵巧指针所拥有，除p1外，还有p2所拥有的 test 类中的灵巧指针p，p2亦然。也就是说，这两块内存的指针的引用记数都为 2 。当程序执行离开作用域后，p1，p2被析构，使它们的引用记数都为1，此后再没有灵巧指针被析构而使它们的引用记数变为 0 ，因此它们将长期保留在堆中。这就象两个被锁住的箱子，其中每个箱子中都装着对方的钥匙，但却无法把彼此打开，这就是互锁现象。
      可是如何解决呢？看来必须对它进行改进。同时，我也发现上面的方法不支持多线程。所以，我们改进后的方法不仅要解决互锁现象，而且还要支持多线程。下面是我改进后的方法：
   首先是如何发现这种互锁现象。我们知道，互锁现象产生的根源在于拥有堆中内存的灵巧指针本身也存在于已分配的堆内存中，那么，如何发现灵巧指针是存在于堆中还是栈中就成了问题的关键。由此，我引入了一个新的类 cptr，由它来管理用 new 分配的指针，而 cptrmanager 专门用来管理 cptr。如下所示：
class cptr
{
 friend class cmark;
public:
 int getptrsize();  file://得到用 new 分配指针的内存的大小
 cmutex * getcmutex(); file://用于线程同步
 void * getptr(); file://得到用 new 分配的指针
 cptr();
 virtual ~cptr();
 int getcount(); file://得到引用记数
           void addautoptr(void * autoptr,int automark);//加入一个拥有该指针的灵巧指针
 bool deleteautoptr(void * autoptr); file://释放一个灵巧指针的拥有权
 void setptr(void * theptr,int size,          int mark,int count=0);  file://设置一个新的指针
 
    void operator delete(void * p)
 {
   free(p);
 }
    void * operator new(size_t size)
 {  
      return malloc(size);
 }

private:
 int m_mark;  file://指针标志
 int m_count; file://引用记数
 void * m_ptr; file://分配的指针
 int m_size; file://指针指向内存的大小
 cptrarray autoptrarray; file://存放拥有该指针的所有灵巧指针的指针数组
 cuintarray m_automark; file://灵巧指针标志：0 in the stack; >0 =mark
 cmutex mutex; file://用于线程同步
};
class cptrmanager 
{
public:
 int getautomark(void * ptr); file://通过灵巧指针的指针，得到灵巧指针标志
 cptrmanager();
 virtual ~cptrmanager();
 int getmarkfromptr(void * ptr);
 void *mallocptr(size_t size);
           bool bcanwrite();
 void deleteptr(int mark,void * ptr);
 void addptr(void *ptr,int ptrsize);
 static cptrmanager * getptrmanager();
 cptr * getcptr(void * ptr,int mark);//通过指针和指针标志得到存放该指针的 cptr

private:
           cptrarray m_ptr; file://存放 cptr 的指针数组
 void*  pcurrent;
 unsigned int m_mark;
 cuintarray m_removed;
 bool bwrite; file://在解决互锁现象的过程中，谢绝其它线程的处理
 static cptrmanager * p_this;
 cmutex mutex;//用于线程同步
 cmarktable mymarktable;
 void removelockres(); file://处理互锁内存
 void copyallmark(); file://处理互锁现象前，先对所有的cptr进行拷贝
 static uint mythreadproc(lpvoid lparm); file://处理互锁现象的线程函数
 cwinthread* mythread;
 void beginthread()
 { mythread=afxbeginthread(mythreadproc,this,thread_priority_above_normal);}
};
   上面的应用中加入了灵巧指针的标志，其实，这个标志就等于该灵巧指针所存在的内存的指针的标志。例如：我们用 new 分配了一个 test 指针，假如这个指针的标志 mark=1，那么，这个 test 中的灵巧指针 auto_ptr p 的标志 automark=1。如果一个灵巧指针存在于栈中，那么它的 automark=0。反之亦然，如果一个灵巧指针的 automark 等于一个指针的 mark，那么，该灵巧指针必存在于这个指针所指的内存中。可是，如何得到这个标志呢，请看下面这个函数的实现：
int cptrmanager::getautomark(void *ptr)
{
    csinglelock singlelock(&mutex);
    singlelock.lock(); file://线程同步

  int size =m_ptr.getsize();
  for(int i=1;i  {
      cptr* thecptr=(cptr*)m_ptr[i];
      if(thecptr)
      {
   int ptrfirst=(int)thecptr->getptr();//得到内存的首指针
   int ptrend=ptrfirst+thecptr->getptrsize();//得到内存的尾指针
   int p=(int)ptr; file://灵巧指针的指针
   if(p>=ptrfirst&&p<=ptrend)//比较灵巧指针的指针是否在首尾之间
                   return  i;
      }
  }
  return 0;
}
    这个函数的原理就在于：如果一个灵巧指针存在于一块内存中，那么该灵巧指针的指针必在这块内存的首尾指针之间。
    解决了灵巧指针的位置问题，下一步就是要找出所有被互锁的内存的指针。这个好实现，只要所有拥有这个指针的灵巧指针的 automark > 0 ，那么，这块内存就可能被互锁了(注意只是可能)，接着看下面的实现：
class cmark
{
 friend class cmarktable;
public:
 cmark(){}
 virtual ~cmark(){}

    void operator delete(void * p)
 {
   free(p);
 }
    void * operator new(size_t size)
 {  
            return malloc(size);
 }
 void copyfromcptr(cptr* thecptr); file://从 cptr 中拷贝相关信息
 bool bisnoneinstack(); file://判断拥有该指针的所有灵巧指针是否都不在栈中
 void release(); file://解除该指针的互锁
private:
 int m_mark; file://指针的标志
 cptrarray autoptrarray; file://拥有该指针的所有灵巧指针的指针数组
 cuintarray automarkarray;//拥有该指针的所有灵巧指针的标志

};
class cmarktable
{
public:
 cmarktable(){init();}
 virtual ~cmarktable(){}
 
 void addcmark(cmark * thecmark);
 bool findmark(int mark);
 void init();
 void dolockmark(); file://处理互锁问题
private:
 cptrarray cmarkarray; file://暂存从cptrmanager 中拷贝过来的指针信息的 cmark 指针数组
 cptrarray clockmarkarray; file://存放互锁的内存
 void getlockmark(); file://得到所有可能被互锁的内存的 cmark，结果存放于clockmarkarray
 bool findlockmark(int mark); file://判断一个灵巧指针是否存在于clockmarkarray所包含的指针中
 void removeunlockmark();//去除假的互锁内存
 void removegroup(int automark);//对互相有联系的相互死锁的内存进行分组

};
   这里又引入了两个类：cmark 和 cmarktable ，这是为了在处理互锁问题之前，对 cptrmanager 中的 cptr 进行快速拷贝，以防止影响其它线程的正常运行。其实，这里的 cmark 与 cptr 没有什么区别，它只是简单地从 cptr 中拷贝信息，也就是说，它等同于 cptr 。
   为了处理互锁问题，先要把可能被互锁的内存指针找出来，看下面函数的实现：
void cmarktable::getlockmark()
{
 clockmarkarray.setsize(0);
 int size=cmarkarray.getsize();
 for(int i=0;i {
  cmark * themark=(cmark*)cmarkarray[i];
  if(themark)
  {
    if(themark->bisnoneinstack())
      clockmarkarray.setatgrow(i,themark);
  }
 }
}
   把这些内存找出来之后，就需要把那些假锁的内存找出来，什么是假锁呢？看下面的例子：
   对于指针 ptra ，如果它的灵巧指针 autoa 存在于指针 ptrb 中，而 ptrb 的灵巧指针 autob 又存在于 ptra 中，那么 ptra 和 ptrb 是真锁，但是如果ptrb 的灵巧指针 autob 存在于指针 ptrc 中，而 ptrc的灵巧指针 autoc 存在于栈中，那么， ptra 和 ptrb 属于假锁。怎么找出假锁的内存呢？看下面函数的实现：
void cmarktable::removeunlockmark()
{
cuintarray unlockmarkarray;
bool bnoneremoveed;
do
{
 bnoneremoveed=true;
 unlockmarkarray.setsize(0);
 int size=clockmarkarray.getsize();
 for(int i=0;i {
    cmark * themark=(cmark*)clockmarkarray[i];
    if(themark)
    {
       int size1=(themark->automarkarray).getsize();
                 for(int j=0;j       {
         int mark=(themark->automarkarray)[j];
         if(!findlockmark(mark)) file://判断灵巧指针是否存在于clockmarkarray所包含的指针中
         {
  unlockmarkarray.insertat(0,i); file://record to remove
  bnoneremoveed=false;
  break;
          }
        }
     }
    else
    {         unlockmarkarray.insertat(0,i);
       bnoneremoveed=false;
     }
 }
 int size2=unlockmarkarray.getsize();
 for(int k=0;k {
    int m=unlockmarkarray[k];
    clockmarkarray.removeat(m);
 }
}while(!bnoneremoveed);

}
    上面函数的原理就是：不停地删除那些灵巧指针不在clockmarkarray所包含的指针中的指针，直到所有的指针的灵巧指针都存在于clockmarkarray所包含的指针中。
    所有被互锁的内存被找出来了，那么，下一步就是如何解锁的问题了。由此，我对灵巧指针引入了一个父类parent_autoptr 如下：
class parent_autoptr
{
public:
 parent_autoptr()
 {thisautomark=0;}
 virtual ~parent_autoptr(){}
 virtual void release(){} file://释放指针的拥有权
protected:
 int thisautomark; file://存放灵巧指针标志
};
    在灵巧指针中，对函数 release() 进行了重载。
template
class auto_ptr :public parent_autoptr
{
   public:
    virtual void release(){remove();}
    auto_ptr()
    {mark=0;pointee=0;thisautomark=getautomark();}
    auto_ptr(auto_ptr&rhs);
    auto_ptr(t*ptr);
    ~auto_ptr(){remove();}
    t*operator->() const;
    operator t*();
    t&operator*()const;
    auto_ptr&operator=(auto_ptr&rhs);
              auto_ptr&operator=(t*ptr);
   private:
              void remove();
    int getautomark();
    cmutex *getcmutex();
    void readywrite();
    t*pointee;
    int mark;
   
};
    在 cmarktable 和 cmark 中对互锁内存进行了释放，如下：
void cmarktable::dolockmark()
{
getlockmark();
removeunlockmark();

int size=clockmarkarray.getsize();
while(size)
{
 cmark* themark=(cmark*)clockmarkarray[0];
 clockmarkarray.removeat(0);
 if(themark)
 {
    int size2=(themark->automarkarray).getsize();
    for(int i=0;i    {
       int automark=（themark->automarkarray)[i];
       removegroup(automark);
     }
    themark->release();
 
 }
 size=clockmarkarray.getsize();
}

init();
}

void cmark::release()
{
    int size=autoptrarray.getsize();
    for(int i=0;i   {
 parent_autoptr * theptr=(parent_autoptr *)autoptrarray[i];
 theptr->release();
   }
}

       到了现在，终于算是大功告成了，我马上把它投入测试当中，发现工作得非常好，即使开辟20至30个线程，程序也工作得很好，并没有抛出异常，而且垃圾回收的功能也非常好。但是，如果线程太多，那么在 cptrmanager 中为了保证线程同步，将会造成瓶颈效应，严重者将会严重影响执行效率。同时，如果每个线程都不停地产生死锁内存，那么，垃圾回收将应接不暇，时间长了，也会造成系统的资源耗尽。
    代码的使用很简单，你只需要将我所附的两个文件加入到工程中，然后，在你的 c*app 中加入如下一段代码就行了：
     cptrmanager theptrmanager;
    这将保证 theptrmanager 在进程最后结束的时候才被析构。
    如果你是在一个新的工程中使用，这就够了，但是，如果你还要使用原来的代码，特别是有指针参数的传递时，那么，你必须注意了。
    如果需要从老代码中接收一个指针，而且这个指针需要你自己释放，那么可以使用灵巧指针，如果不需要释放，那么只能使用一般指针；
    如果需要传递一个指针给老代码，而且这个指针需要你自己释放，那么可以使用灵巧指针，否则，只能使用一般指针。