再论智能指针（下）

1. SharedPointer的设计要点

(1)使用类模板技术

(2)通过计数机制(ref)标记堆内存：

• 堆内存被执向时，ref++
• 堆内存被释放时，ref--
• ref为零时释放所执向的堆内存

2. 计数机制原理剖析

3. SharedPointer类的声明

template <typename T>
class SharedPointer : public Pointer<T>
{
protected:
    int* m_refCount; //计数机制成员
public:
    SharedPointer(T* p = NULL);
    SharedPointer(const SharedPointer<T>& obj);
    
    SharedPointer<T>& operator=(const SharedPointer<T>& obj);
    
    void clear(); //将当前指针置为空
    
    //由于SharedPointer支持多个对象同时指向一片堆空间
    //因此必须支持比较操作！
    bool operator==(const SharedPointer<T>& obj);
    bool operator!=(const SharedPointer<T>& obj);
    
    ~SharedPointer();
};

note:

代码中的计数变量是使用了一个指针指向的堆空间，这样做是由于：

智能指针指向的对象是在堆空间，为了保持计数变量与智能指针指向的对象保持相同的生命周期，计数变量应该也是在堆空间中。

4. SharedPointer类的实现

SharedPointer.h

#ifndef _SHAREDPOINTER_H_
#define _SHAREDPOINTER_H_

#include "Pointer.h"
#include "exception.h"
#include <cstdlib>

namespace DataStructureLib 
{
    template <typename T>

    class SharedPointer :public Pointer<T>
    {
    protected:
        int* m_ref;//计数机制成员
        
        void assign(const SharedPointer<T>& obj)
        {
            this->m_pointer=obj.m_pointer;
            this->m_ref=obj.m_ref;

            if ( obj.m_ref)
            {    
                (*this->m_ref)++;
            }     
        } 
    public:
        SharedPointer(T* p=NULL):Pointer(NULL) //构造函数  显式调用父类的构造函数
        {
            if (p)
            {
                this->m_ref=static_cast<int*>(malloc(sizeof(int)));
                if (this->m_ref)
                {
                    *(this->m_ref)=1;
                    this->m_pointer=p;
                    
                }
                else
                    THROW_EXCEPTION(NotEnoughMemoryException,"No memory to create SharedPointer object ... ");
            }
        }

        SharedPointer(const SharedPointer<T>& obj):Pointer(NULL)
        {
            assign(obj);
        }

      SharedPointer<T>& operator =(const SharedPointer<T>& obj)
      {
          if (this!=&obj)
          {
             clear();//如果当前的sharepointer指针已经指向 另外一片堆空间，应该先置空当前指针,不让它指向任何堆空间
             assign(obj);
          }
         

          return *this;
      }

      void clear()
      {//置空函数
          T* todel=this->m_pointer;
          int *ref=this->m_ref;

          this->m_pointer=NULL;
          this->m_ref=NULL;

          if ( ref)
          {
              (*ref)--;//释放一个指针减1

              if (*ref==0)//若堆空间没有对应的指针指向
              {
                  free(ref);
                  ref=NULL;
                 
                  delete todel;
              }
          }
      }

      ~SharedPointer()
      {
          clear();
      }
    };
    
    
    
    //由于SharedPointer支持多个对象同时指向一片堆空间。因此必须支持比较操作！

    template<typename T>
    bool operator == (const SharedPointer<T>& l,const SharedPointer<T>& obj)
    {
        return (l.get()==obj.get());
    }

    template<typename T>
    bool operator !=(const SharedPointer<T>& l,const SharedPointer<T>& obj)
    {
        return !(l==obj);
    }



}

#endif

测试代码：

#include<iostream>
#include "SharedPointer.h"
using namespace std;
using namespace DataStructureLib;

class Test : public Object
{
    
public:
    int m_value;
    Test():m_value(0)
    {
        cout << "Test()" << endl;
    }

    ~Test()
    {
        cout <<"~Test()" << endl;
    }
};
int main(int argc, char const *argv[])
{
    SharedPointer<Test> sp0 = new Test();
    SharedPointer<Test> sp1 = sp0;
    SharedPointer<Test> sp2 = NULL;

      sp2 = sp1;

      sp0->m_value=100;

      cout << sp0->m_value << endl;
      cout << sp1->m_value << endl;
      cout << sp2->m_value << endl;
    //system("pause"); 
    return 0;
}

结果

5.智能指针使用军规

（1）只能用来指向堆空间中的单个对象（变量）

（2）不同类型的智能指针对象不能混合使用

（3）不要使用delete释放智能指针指向的堆空间

6.小结

 (1)SharedPointer最大程度的模拟了原生指针的行为

 (2)计数机制确保多个智能指针合法的指向同一片堆空间

 (3)智能指针只能用于指向堆空间中的内存（不能是栈空间或者全局区的内存数据）

 (4)不同类型的智能指针（上一节和这一节的两种）不要混合使用

 (5)堆对象的生命周期由智能指针进行管理（申请和删除）