解析Boost库智能指针(smart pointer)实现原理

古城微笑少年丶 2022-05-22 10:17 253阅读 0赞

### 引言： ###

我们在写c++程序的时候，经常会因为忘记释放指针的资源从而导致内存泄漏，基于指针的这种缺陷，boost库中就提供了一种称之为“Smart Pointer"的类来解决这个问题，让程序自己控制已经不需要的资源的释放。后来”Smart Pointer”中的部分也移植到了c++标准库。

下面这些smart pointer的设计思想都是：**定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，然后在析构函数完成资源的清理**，由于在在作用域结束的时候会自动调用析构函数，所以就起到了资源自动释放的效果。

#### auto\_ptr ####

智能指针的实现都采用了泛型的思想，即可以用来操作任何类型的数据：内置类型，自定义。所以采用了模板类的实现方案作为框架。

因为智能指针要满足指针的一切操作，所以需要在内部实现`->`，`*`，`=`等运算符的重载。基于以上这些思路，我们就足以实现一个最初版本的`auto_ptr`

*  最初版本的auto\_ptr

template<typename T>
    class AutoPtr{ 
    public:
    	AutoPtr(T *p = NULL)
    		:_ptr(p)
    	{ }
    	AutoPtr(const AutoPtr<T> &a){ 
    		_ptr = a._ptr;
    	}
    	Auto<T>& operator=(const AutoPtr<T> &a){ 
    		if (this != &a){ 
    			_ptr = a._ptr;
    			a._ptr = NULL;
    		}
    	}
    	T& operator*(){ 
    		return *_ptr;
    	}
    	T& operator*(){ 
    		return *_ptr;
    	}
    	T* operator->(){ 
    		return _ptr;
    	}
    	~AutoPtr(){ 
    		if (_ptr){ 
    			delete _ptr;
    		}
    	}
    private:
    	T *_ptr;
    };

**缺陷：** 无法用多个指针操作同一块空间。  
为了避免这个缺陷，我的解决思路是这样的：  
提供一个当前标签，每一块空间只有一个指针拥有当前标签，而其他的指向这块空间的指针都具有使用权，在调用析构函数的时候，只有释放的指针具有当前标签的，才真正释放指针所指向的空间资源，这样就解决了上面的问题。

优化后的`auto_ptr`:

template<typename T>
    class AutoPtr
    { 
    public:
    	AutoPtr(T *ptr = NULL) :
    		_ptr(ptr),
    		_flag(true)
    	{ }
    	AutoPtr(const AutoPtr<T> &a) :
    		_ptr(a._ptr),
    		_flag(a._flag)
    	{ 
    		a._flag = false;
    	}
    	AutoPtr<T>& operator=(const AutoPtr<T> &a)
    	{ 
    		if (this != &a)
    		{ 
    			_ptr = a._ptr;
    			_flag = a._flag;
    			a._flag = false;
    		}
    	}
    	T& operator*(){ 
    		return *_ptr;
    	}
    	T* operator->(){ 
    		return _ptr;
    	}
    	~AutoPtr()
    	{ 
    		if (ptr && flag == true){ 
    			delete _ptr;
    		}
    	}
    
    private:
    	T *_ptr;
    	mutable bool _flag;
    };

**产生的新的缺陷：**  
1.引用内置类型变量的时候，在释放对象的时候会产生未定义的结果  
2.看下面这段代码：

AutoPtr<int> p1(new int(10));
    if (1)
    {
    	AutoPtr<int> p2(p1);
    }

出了if的作用域后，局部对象p2就会被释放，由于是用p1拷贝构造的p2,所以p1内部指针指向的内容也会被释放掉，因此，p1会变成野指针。这就是第二种缺陷。

#### shared\_ptr ####

这种智能指针的实现是非常成熟的，可以满足指针的一切需求，如果需要使用 [RAII][] 这种机制，推荐使用`shared_ptr`

//配置删除器(仿函数）
    template<typename T>//new
    class Del
    { 
    public:
    	void operator()(T* &pos)
    	{ 
    		if (pos)
    		{ 
    			delete pos;
    		}
    	}
    };
    template<typename T>//malloc
    class Free
    { 
    public:
    	void operator()(T* &pos)
    	{ 
    		if (pos)
    		{ 
    			free(pos);
    		}
    	}
    };
    class FClose//FILE
    { 
    public:
    	void operator()(FILE* &pos)
    	{ 
    		if (pos)
    		{ 
    			fclose(pos);
    		}
    	}
    };
    
    template<typename T,typename Des = Del<T> >
    class shared_ptr
    { 
    public:
    	shared_ptr(T *ptr = NULL)
    		:_ptr(ptr)
    		, _count(new int(0))
    	{ 
    		if (ptr){ 
    			*_count = 1;
    		}
    	}
    	shared_ptr(shared_ptr<T, Des> &p)
    		:_ptr(p._ptr)
    		, _count(p._count)
    	{ 
    		if (_ptr){ 
    			++(*_count);
    		}
    	}
    	shared_ptr<T>& operator=(shared_ptr<T, Des> &p){ 
    		if (this != &p){ 
    			_ptr = p._ptr;
    			_count = p._count;
    			if (_ptr){ 
    				++*_count;
    			}
    		}
    	}
    	T& operator*(){ 
    		return *_ptr;
    	}
    	T* operator->(){ 
    		return _ptr;
    	}
    	~shared_ptr(){ 
    		if (*_ptr && --*_count == 0){ 
    			_des(_ptr);
    		}
    	}
    
    private:
    	T *_ptr;
    	int *_count;
    	Des _des;//删除器
    };

> shared\_ptr 也存在一定的问题，请看下面这种情况：

template <class T>
    struct ListNode
    { 
    	//两个`>`之间有空格，因为有些老的编译器无法识别连续两个`>`
    	shared_ptr<ListNode<T> > _pre;
    	shared_ptr<ListNode<T> > _next;
    	T _data;
    }
    //test.cc
    void main()
    { 
    	shared_pre<ListNode<T> > p1(new ListNode<int>(1));
    	shared_pre<ListNode<T> > p2(new ListNode<int>(2));
    	p1->_next = p2;
    	p2->_pre = p1;
    }

**代码讲解：** main函数结束时，需要销毁p1 和 p2，p2的引用计数-1后为1，因为还有其他的智能指针在使用，即p1的\_next，因此此时不能释放p2节点；同理，  
p1亦不能释放，这样一来就导致**内存泄漏**。

> 要解决以上这种问题（循环引用），就得借助weak\_ptr，上面这段代码这样改就不会出现问题了：

template <class T>
    struct ListNode
    { 
    	weak_ptr<ListNode<T> > _pre;
    	weak_ptr<ListNode<T> > _next;
    	T _data;
    }
    //test.cc
    void main()
    { 
    	shared_pre<ListNode<T> > p1(new ListNode<int>(1));
    	shared_pre<ListNode<T> > p2(new ListNode<int>(2));
    	p1->_next = p2;
    	p2->_pre = p1;
    }

--------------------

除了上面那两种和正常指针没有什么区别的智能指针外，boost库还提供了一种指针，这种指针禁止赋值和拷贝构造。也就是说，一块资源只能由一个指针管理，这种指针后来移植到了C++标准库后，换了个名字可能更加贴切它的用法一点`uniqued_ptr`  
下面是它的实现代码：

#### scoped\_ptr(uniqued\_ptr) ####

scoped_ptr
    template<typename T>
    class ScopedPtr
    { 
    public:
    	ScopedPtr(T *ptr = NULL) :
    		_ptr(ptr),
    		_flag(true)
    	{ }
    	T& operator*(){ 
    		return *_ptr;
    	}
    	T* operator->(){ 
    		return _ptr;
    	}
    	~ScopedPtr()
    	{ 
    		if (ptr && flag == true){ 
    			delete _ptr;
    		}
    	}
    
    private:
    	ScopedPtr(const ScopedPtr<T>& s);
    	ScopedPtr<T>& operator = (const ScopedPtr<T>& s);
    private:
    	T *_ptr;
    	mutable bool flag;
    };

[RAII]: https://baike.baidu.com/item/RAII/7042675?fr=aladdin