C++中的智能指针

一，为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题？提示一下：注意分析MergeSort 函数中的问题

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
   // 2、如果p2这里new 抛异常会如何？
   // 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

上述代码问题：内存泄漏

二，内存泄漏

什么是内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对 该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	Func();
	delete[] p3;
}

三，智能指针的使用及原理

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在 对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处：

• 不需要显式地释放资源
• 采用这种方式，对象所需的资源在其生命期内始终保持有效

std::auto_ptr简单实现：

// C++98  管理权转移  auto_ptr
 
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		auto_ptr(auto_ptr& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;
		}
		auto_ptr& operator=(auto_ptr& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;
			}
			return *this;
		}
		// 转移ap中资源到当前对象中
		_ptr = ap._ptr;
		ap._ptr = NULL;
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
//  std::auto_ptr sp1(new int);
//  std::auto_ptr sp2(sp1); // 管理权转移
//
 //  // sp1悬空
//  *sp2 = 10;
 //  cout << *sp2 << endl;
 //  cout << *sp1 << endl;
 //  return 0;
 //}

std::unique_ptr简单实现

// unique_ptr/scoped_ptr
 // 原理：简单粗暴 -- 防拷贝
 
 
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
			~unique_ptr()
		{
		}
		if (_ptr)
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr& sp) = delete;
		unique_ptr& operator=(const unique_ptr& sp) = delete;
	private:
		T* _ptr;
	};
 
//int main()
//{
//  /*bit::unique_ptr sp1(new int);
//  bit::unique_ptr sp2(sp1);*/
//
//  std::unique_ptr sp1(new int);
//  //std::unique_ptr sp2(sp1);
//
//  return 0;
//}

std::shared_ptr简单实现

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共 享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对 象就成野指针了

template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pRefCount(new int(1))
		, _pmtx(new mutex)
	{}
	shared_ptr(const shared_ptr& sp)
		:_ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pmtx(sp._pmtx)
	{
		AddRef();
	}
	void Release()
	{
		_pmtx->lock();
		bool flag = false;
		if (--(*_pRefCount) == 0 && _ptr)
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
			delete _pRefCount;
			flag = true;
		}
		_pmtx->unlock();
		if (flag == true)
		{
			delete _pmtx;
		}
	}
	void AddRef()
	{
		_pmtx->lock();
		++(*_pRefCount);
		_pmtx->unlock();
	}
	shared_ptr& operator=(const shared_ptr& sp)
	{
		//if (this != &sp)
		if (_ptr != sp._ptr)
		{
			Release();
				_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pmtx = sp._pmtx;
			AddRef();
		}
		return *this;
	}
	int use_count()
	{
		return *_pRefCount;
	}
	~shared_ptr()
	{
		Release();
	}
	// 像指针一样使用
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T* get() const
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pRefCount;
	mutex* _pmtx;
};

weak_ptr简单实现

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}
	weak_ptr(const shared_ptr& sp)
		:_ptr(sp.get())
	{}
	weak_ptr& operator=(const shared_ptr& sp)
	{
		_ptr = sp.get();
			return *this;
	}
private:
	T* _ptr;
 };