C++---智能指针

首先要知道智能指针是用来解决什么问题的，首先我们先看下面这段代码

void Func(int *p)
{
	int *sp = new int;
	if (p == NULL)
	{
		throw std::exception("p is NULL");
	}
	delete sp;
}

这个函数有一个很大的问题，如果传入的参数p为空，遇到 if 语句就命中之后就会抛出异常，程序中断。那么指针sp指向开辟的内存没有释放，导致内存泄漏。有什么方法可以来解决这个问题？

栈：系统开辟内存，系统释放；堆：手动开辟内存，手动释放。那么如果能对堆上空间实现用户分配、系统自行回收的机制，就不用担心内存泄露的问题了。

智能指针的思想：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数中完成资源的清理和释放，可以保证资源的正确使用和释放。(资源指的是堆上资源)

看下面这段代码：

#include<iostream>
template <typename T>
class Smart_ptr
{
public:
	Smart_ptr(T *ptr) :mptr(ptr)//构造函数
	{}
	~Smart_ptr()//析构函数
	{
		delete mptr;
		mptr = NULL;
	}
	
	T& operator*()//*运算符重载
	{
		return *mptr;
	}
	T* operator->()//->运算符重载
	{
		return mptr;
	}
private:
	
	T *mptr;
};

int main()
{
	Smart_ptr<int>sp1(new int);
	*sp1 = 20;
	Smart_ptr<int>sp2 = sp1;
}

Smart_ptr<int>sp2 = sp1;这句代码会释放同一块内存两次，导致程序出错。

这里介绍四个智能指针auto_ptr

1、auto_ptr（已经被摒弃）

实现一：不带标记的auto_ptr（所有权唯一）

            

#include<iostream>
template <typename T>
class Smart_ptr
{
public:
	Smart_ptr(T *ptr) :mptr(ptr)
	{}
	~Smart_ptr()
	{
		delete mptr;
		mptr = NULL;
	}
	Smart_ptr(const Smart_ptr<T>& rhs)//拷贝构造函数
	{
		mptr = rhs.mptr;
		rhs.Release();//将旧的指针置为NULL
	}
	Smart_Ptr<T>& operator=(const Smart_Ptr<T>& rhs)//赋值运算符重载
	{
		if (this != &rhs)
		{
			delete mptr;
			mptr = rhs.mptr;
			rhs.Release();//将旧的指针置为NULL
		}
		return *this;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	void Release()const
	{
		(T*)mptr = NULL;
	}
	T *mptr;
};

int main()
{
	Smart_ptr<int>sp1(new int);
	Smart_ptr<int>sp2 = sp1;
	*sp1 = 20;
}

问题：*sp1 = 20; sp1指针指向已经为NULL，对其解引用访问了保留区的数据，程序出错。

实现二：带有标记的auto_ptr（释放权唯一，管理权不唯一)，即可以多个auto_ptr管理同一片内存，但是只能有一个指针释放该片内存。怎么确定是哪个指针能释放呢？在成员变量中加入一个标志变量flag，flag为true则有释放权，flag为false则没有释放权。那么就牵扯释放权限转移的问题，概括来说就是旧智能指针拥有的权限，那么新智能指针也拥有。旧智能指针没有的权限，那么新智能指针也没有。

                           

这个功能的实现：new flag = old flag;   old flag = false;

#include<iostream>
template<typename T>
class SmartPtr
{
public:
	SmartPtr(T* ptr) :mptr(ptr), flag(true)
	{}
	SmartPtr(const SmartPtr<T>& rhs) :mptr(rhs.mptr)
	{
		flag = rhs.flag;
		rhs.flag = false;
	}
	SmartPtr<T>& operator = (const SmartPtr<T>& rhs)
	{
		if (this != &rhs)
		{
			this->~SmartPtr();
			mptr = rhs.mptr;
			flag = rhs.flag;
			rhs.flag = false;
		}
		return *this;
	}
	~SmartPtr()
	{
		if (flag)
		{
			delete mptr;
		}
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	T* mptr;
	mutable bool flag;//是否拥有释放权
};
void func(SmartPtr<int> sp)//true
{}
int main()
{
	SmartPtr<int> sp1(new int);//false
	SmartPtr<int> sp2 = sp1;//false
	func(sp2);
	*sp1 = 20;
	return 0;
}

问题：根据管理权原则一，若旧智能指针有释放权，则新智能指针将释放权拿走，旧释放权false。那么如果这个新智能指针只是一个临时量，随着生存周期的到来也随之消失，那块被管理的内存岂不是莫名其妙就被释放了

void func(SmartPtr<int> sp)//true
{}
void test(SmartPtr<int> rhs)
{
	std:: cout << *rhs << std::endl;
}
int main()
{
	SmartPtr<int> p(new int(10));
	SmartPtr<int> q(new int(20));
	*p = 11;
	*q = 22;
	p = q;
	SmartPtr<int> w = p;
	test(w);//在传参的过程中，w的释放权发生转移

	std::cout << "w" << *w << std::endl;//打印一个随机值
	return 0;
}

 

2、Scope_ptr(管理权唯一，释放权唯一）

在auto_ptr中，因为设计的问题，导致在使用拷贝构造函数和 赋值运算符的可重载函数时，发生了访问 空指针、野指针的情况。为了规避这些情况，scoped_str在设计的时候就直接屏蔽了 拷贝构造函数 和 赋值运算符重载函数。

#include<iostream>
template<typename T>
class Scope_Ptr
{
public:
	Scope_Ptr(T* ptr) :mptr(ptr){}
	~Scope_Ptr()
	{
		delete mptr;
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	Scope_Ptr(const Scope_Ptr<T>&);
	Scope_Ptr<T>& operator=(const Scope_Ptr<T>&);
	T* mptr;
};

int main()
{
	int* p = new int;
	Scope_Ptr<int> sp1(p);
	Scope_Ptr<int> sp2(p);
	return 0;
}

问题： scoped_ptr的原则也是“管理权唯一，释放权唯一”，因为屏蔽了 拷贝构造函数 和 赋值运算符重载函数，所以不可能通过这两种方式去 使得两个及以上的指针指向同一片内存，但是仍然避免不了人为的操作，如sp1和sp2；即初始化两个scope_ptr指向同一片内存，当其中一个指针释放了该内存，另一个再想去修改内存的内容的话程序就会崩溃
3、shared_ptr（管理权不唯一，释放权不唯一）

shared_ptr是基于“引用计数”实现的，多个shared_ptr可指向同一片内存，并且它们维护着共享的引用计数器——记录着指向同一片内存的shared_ptr对象的个数。当最后一个指向某一片内存的shared_ptr对象也销毁之后，会自动销毁掉该片内存。shared_ptr很好地解决了 多个智能指针指向一块内存块时, 析构时程序崩溃 的情况。

引用计数器：我们只需要一个 引用计数器对象，这个对象中就存储了所有关于内存引用的信息。

                

class Ref_Management
{
public:
	void AddRef(void* mptr)//增加
	{
		std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
		if (it == vec.end())//引用计数表中不存在这个地址那么就增加一个
		{
			Node tmp(mptr, 1);
			vec.push_back(tmp);
		}
		else
		{
			(*it).ref++;//存在，那么就加引用计数
		}
	}
	void DelRef(void* mptr)//删除
	{
		std::vector<Node>::iterator fit = find(mptr);//查找是否存在这个地址
		if (fit == vec.end())//如果找到最后都没有，那么就不存在抛出异常
		{
			throw std::exception("mptr is not exisit!");
		}
		else
		{
			if (GetRef(mptr) != 0)//判断该地址的引用计数
			{
				(*fit).ref--;//计数不为0就--
			}
		}
	}
	int GetRef(void* mptr)//获取
	{
		std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
		if (it == vec.end())//如果找到最后都没有，那么就不存在抛出异常
		{
			throw std::exception("ptr is not exsit!");
		}
		else
		{
			return (*it).ref;//找到返回引用计数
		}
	}
private:
	class Node;
	std::vector<Node>::iterator find(void* mptr)//使用迭代器查找
	{
		std::vector<Node>::iterator it = vec.begin();
		for (it; it != vec.end(); it++)
		{
			if ((*it).addr == mptr)
			{
				break;
			}
		}
		return it;
	}

	class Node//结点类型
	{
	public:
		Node(void* pa = NULL, int r = 0) :addr(pa), ref(r){}//构造函数
	public:
		void* addr;//存放的地址
		int ref;//引用计数
	};
	std::vector<Node> vec;
};

template<typename T>
class Shared_Ptr
{
public:
	Shared_Ptr(T* ptr) :mptr(ptr)//构造函数
	{
		addref();
	}
	Shared_Ptr(const Shared_Ptr<T>& rhs) :mptr(rhs.mptr)//拷贝构造函数
	{
		addref();//增加引用计数
	}
	Shared_Ptr<T>& operator = (const Shared_Ptr<T>& rhs)//赋值运算符重载
	{
		if (this != &rhs)//防止自赋值
		{
			delref();//减引用计数
			if (getref() == 0)//若引用计数为0，删除该指针
			{
				delete mptr;
			}
			mptr = rhs.mptr;
			addref();
		}
		return *this;
	}
	~Shared_Ptr()
	{
		delref();//减引用计数
		if (getref() == 0)//若引用计数为0，删除该指针
		{
			delete mptr;
		}
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	void addref()
	{
		rm.AddRef(mptr);
	}
	void delref()
	{
		rm.DelRef(mptr);
	}
	int getref()
	{
		return rm.GetRef(mptr);
	}
	T* mptr;
	static Ref_Management rm;//引用计数器成员变量象
};
//静态成员变量类外初始化
template<typename T>
Ref_Management Shared_Ptr<T>::rm;

int main()
{
	int* p = new int;
	Shared_Ptr<int> sp1(p);
	Shared_Ptr<int> sp2(p);
	Shared_Ptr<int> sp3(p);
	Shared_Ptr<int> sp4(new int);
	return 0;
}

问题：虽然shared_ptr很好地解决了 “多个智能指针指向同一块内存时，析构时出错”的问题，可是同时也带来了新的问题。shared_ptr之间不能相互引用，否则管理的堆上内存块无法释放。