内存管理与智能指针

内存管理与智能指针

 

        作为一名合格的C++程序猿，管理内存是不可逃避的现实。像java,python等这些面向对象的语言来说，它们有垃圾回收机制，不需要程序员来管理内存。然而为了追求效率的C++没有实现这一机制。那么我们就必须借助各种技术来解决内存泄露这一头疼的事情了。

        C++中内存泄露是防不胜防的，因为毕竟人的能力是有限的。那么我们就必须借助一些技术来减少出错的可能。能存管理说的主要是管理由malloc,new分配的堆空间。而操作这些空间的句柄就是指针。归根结底就是对指针的操作。以避免造成野指针，悬垂指针以及内存泄露的情况，看了一些智能指针的例子以及STL后，一直想要动手自己写一套内存管理的工具。

 

一、   基础准备

1.内存分配方式

        要想实现内存管理，首先要了解分配的方式：（1）变量分配，（2）常量的分配。

        1.   变量的分配（class T）

                                    T * pt = new T()

                                    T* pt = new T(const T&t)

        这两种方式分别用到了默认构造函数，以及拷贝构造函数，对于带形参的构造函数的调用有待使用变长参数列表实现。

        2.   常量的分配（class）

                                     const T* pt = new const T()

                                     const T* pt = new const T(const T& t)

２．内存分配表

        通过维护一个内存分配表来实现对已分配内存的动态跟踪，对于内存分配表也有两种实现方案：（１）全局分配表；（２）类型分配表。

        1.  全局分配表

        指的是整个程序共有同一份分配表，那么分配表。这里会有一个技术问题，分配的内存类型并不统一，那么存储形式只能是如下两种情况：

                                                                        a.   map<void*,int*>

                                                                        b.   map<Object*,int*>

        对于a我们无法通过分配表来实现对内存的释放，C++无法delete空指针。那么我们只能在智能指针的对象中对其进行释放（因为它了解自己的类型）。但是这有一个问题，当我们分配了一段内存，但没有任何智能指针指向它时，它将无法释放。有一个解决方案，那就是在构造时内部默认生成一个智能指针指向它，这回带来不必要的内存开销。或者强制要求用户必须用至少一个职能指针指向分配器分配的内存。不仅如此，在性能上整个程序共有一个分配表会造成分配表size异常的庞大，影响查询速度，同时影响多线程程序的速度。所以此方案不可取。

        对于Object是一个公有子类，任何其他类必须继承它，它有一个虚析构函数，这样可以实现统一销毁对象。然而C++中没有这个公共子类，那么适用范围为：（１）自定义类型；（２）包装已有类型。

class Object{public:    Object(){}    virtaul  ~Object() = 0;}template<classT>class Dynamic:public　Object{public:    Dynamic();    Dynamic(const T&);    Dynamic(const Dynamic&);    T&  self();private:    T data;};

        这样包装之后可以让所有类型从某种意义上来说继承自Object.对于处理自定义类型那就更加容易了，只需要一个公共基类，当然使用（２）同样可以处理自定义类型。

        2.    类型分配表  

        指的是一个类型一个分配表，如int,string等每个类型一个分配表。这样的话我们智能指针可以跟踪内存的释放，同时当出现遗漏时，如没有任何智能指针指向该段内存，分配器可以负责释放（因为此时分配器知道自己分配的具体类型）。同时这样分配表也会相对较短，查找效率更高。此时的分配表为：

                                                                            map<T*,int*>

3.    python思想迁移

      

        我们可以想想，其实所有分配在栈和静态存储区的存储空间都是由一个变量来标识，这是由系统自己管理的内存空间，而堆上分配的空间在每次运行期都是不定的，也就是不是编译期决定的，所以只能用指针来标识。那么我们是否可以将这种指针标识的内存空间标量化，对象化呢？其实是可以的，事实上python就是这么做的。通过采用引用计数的方式来管理这段内存。我们实现在此:C++实现Python变量。

二、   需求分析

        除了上面的python思想实现了之外，我们还需要实现类型分配表这种方法。我们需要的功能有：

       1.  每个类型有个统一的内存分配器alloctor负责分配内存，同时alloctor维护者一个内存分配表map<T*,int*>(int*用于引用计数)。

       2.  每种类型有个成员生成器Dynamic<T>::Construct()。

       3.  智能指针跟踪内存分配表的引用计数。

       4.  当智能指针与空间脱离绑定（生命周期结束／指向其他空间），检测到引用计数为０时，调用分配器的销毁函数destroy(T*)对其 进行销毁。当程序结束时分配器会检查遗漏的空间，并将其一并销毁。

       5.  程序员被建议不要显示使用malloc/free,new/delete关键字，如果使用了，那么这部分资源的释放你必须负责。

       6.  这种智能指针的好处在于，它可以指向静态数据和栈数据。而依据python思想设计的Obj_ptr永远都不会和这两类数据邦定。两者的差异还是较为明显的。基于类型分配表方案的设计，智能指针仍然具有指针语义，它可以是NULL，而基于python的设计思想Obj_ptr已经具有值语义。

三、   实现

１．Alloctor(分配器)

template<class T>class Alloctor{public:typedef typename map<T*,int*>::value_type  value_type;typedef typename map<T*,int*>::iterator  iterator;public:Alloctor(){}//template<class T>T* Construct(){T *get = new T();T *p = get;int *useCount = new int(0);obj.insert(value_type(p,useCount));return get;}//template<class Ty>T* Construct(const T &t){T *get = new T(t);T *p = get;int *useCount = new int(0);obj.insert(value_type(p,useCount));return get;}~Alloctor();int* getUseCount(T* oj);bool getElement(iterator iter,T* oj);void destroy(T* oj);int  ListLen(){return obj.size();}private:map<T*,int*> obj;};////////////////////////////////////////////////////////////////////////////////////////////template<class T>Alloctor<T>::~Alloctor(){std::cout<<"Alloctor<T>::~Alloctor()"<<std::endl;typename map<T*,int*>::iterator iter = obj.begin();typename map<T*,int*>::iterator end = obj.end();for(;iter != end;iter++){delete iter->first;delete iter->second;}}template<class T>int* Alloctor<T>::getUseCount(T* oj){iterator iter = obj.find(oj);if(iter == obj.end())return NULL;else{return iter->second;}}template<class T>bool Alloctor<T>::getElement(iterator iter,T* oj){iter = obj.find(oj);if(iter == obj.end())return false; else{return true;}}template<class T>void Alloctor<T>::destroy(T* oj) //public is not very security.{std::cout<<"Alloctor<T>::destroy(T* oj)"<<std::endl;int *count = getUseCount(oj);if(count != NULL){(*count)--;if(*count == 0){obj.erase(oj);delete oj;}}}

２．成员生成器Dynamic<T>::Construct()

template<class T,class alloc = Alloctor<T> >class Dynamic{public:static T* Construct(){return alloctor.Construct();}static T* Construct(const T &t){return alloctor.Construct(t);}//private:static alloc alloctor;};template<class T,class alloc> alloc Dynamic<T,alloc>::alloctor = Alloctor<T>();

３．智能指针

template<class T>class Obj_ptr{public:typedef typename map<T*,int*>::value_type  value_type;typedef typename map<T*,int*>::iterator  iterator;public:Obj_ptr();Obj_ptr(const Obj_ptr &ptr);   Obj_ptr(T *ptr);Obj_ptr& operator=(const Obj_ptr &ptr);Obj_ptr& operator=(T *ptr);bool operator==(const T *ptr){return p == ptr;}bool operator==(const Obj_ptr &ptr){return p == ptr.p;}T& operator*(){return *p;}T*& operator->(){return p;}~Obj_ptr();void Destory();private:T *p;};///////////////////////////////////////////////////////////////////////////////////////////////*Obj_ptr*/template<class T>Obj_ptr<T>::Obj_ptr(){std::cout<<"Obj_ptr()."<<std::endl;p = NULL;}template<class T>Obj_ptr<T>::Obj_ptr(const Obj_ptr &ptr){std::cout<<"const Obj_ptr(Obj_ptr &ptr)."<<std::endl;p = ptr.p;int *count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){(*count)++;}else{//p = NULL;}}template<class T>Obj_ptr<T>::Obj_ptr(T *ptr){std::cout<<"Obj_ptr(T *ptr)."<<std::endl;p = ptr;int *count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){(*count)++;std::cout<<"count:"<<*count<<std::endl;}else{//p = NULL;}}template<class T>Obj_ptr<T>& Obj_ptr<T>::operator=(const Obj_ptr &ptr){std::cout<<"Obj_ptr operator=(Obj_ptr &ptr)."<<std::endl;if(&ptr != this)//not give self to self.{int *count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){if(*count == 1){Destory();}else{(*count)--;}std::cout<<"count--:"<<*count<<std::endl;}p = ptr.p;count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){(*count)++;std::cout<<"count++:"<<*count<<std::endl;}else{//p = NULL;}}return *this;}template<class T>Obj_ptr<T>& Obj_ptr<T>::operator=(T *ptr){std::cout<<"Obj_ptr operator=(T *ptr)."<<std::endl;int *count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){if(*count == 1){Destory();}else{(*count)--;}std::cout<<"count--:"<<*count<<std::endl;}p = ptr;count = Dynamic<T>::alloctor.getUseCount(p);if(count != NULL){(*count)++;std::cout<<"count++:"<<*count<<std::endl;}else{//p = NULL;}return *this;}template<class T>Obj_ptr<T>::~Obj_ptr(){std::cout<<"Obj_ptr<T>::~Obj_ptr()"<<std::endl;Destory();}template<class T>void Obj_ptr<T>::Destory(){Dynamic<T>::alloctor.destroy(p);}/*Obj_ptr*/

        当然嫌构造器形式太复杂的话，我们可以用个函数将其简化，这都不是关键。