C++——智能指针

一、内存泄露

1.1 内存泄露的概念及危害

什么是内存泄露？

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

内存泄露的危害

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

void MemoryLeaks()
{
	// 1、内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2、异常安全问题
	int* p3 = new int[10];

	// 这里Func函数抛异常导致delete[] p3未执行，p3没被释放
	Func();

	delete[] p3;
}

1.2 内存泄露分类

堆内存泄露（Heap leak）

堆内存是指程序执行中依据须要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存，用完后必须通过调用相应的free或者delete删掉。假设程序的实际错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap leak。

系统资源泄露

指程序使用系统分配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

1.3 如何避免内存泄露

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。但是如果碰上异常时，就算注意释放了，还是可能会出问题。
采用RAII思想或者智能指针来管理资源。
出问题了使用内存泄露工具检测。

【总结】内存泄露非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄露检测工具。

二、智能指针的使用及原理

2.1 RAII

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

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

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

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
	{
		throw invalid_argument("除0错误");
	}
	return a / b;
}

void Func()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);

	cout << div() << endl;
}

int main()
{
	try
	{
		Func();
	}
	catch(const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

2.2 智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容。因此：AutoPtr模板类中还得需要将 *、-> 重载一下，才可以让其像指针一样去使用。

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}

private:
	T* _ptr;
};

struct Date
{
	int _year;
	int _month;
	int _day;
};

int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;

	SmartPtr<Date> sp2(new Date);
	sp2->_year = 2024;
	sp2->_month = 1;
	sp2->_day = 1;
	cout << sp2->_year << "-" << sp2->_month << "-" << sp2->_day << endl;

	return 0;
}

总结一下智能指针的原理：

RAII特性
重载operator*和operator->，具有像指针一样的行为

2.3 unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

// unique_ptr
// 原理：简单粗暴——防拷贝
namespace H
{
	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<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

	private:
		T* _ptr;
	};
}

2.4 shared_ptr

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

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

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace H
{
	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<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			,_pmtx(sp._pmtx)
		{
			AddRef();
		}

		void Release()
		{
			_pmtx->lock();

			bool flag = flase;
			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<T>& operator=(const shared_ptr<T>& 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;
	};
}

shared_ptr的线程安全问题

智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以智能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是线程安全的。
智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

三、C++11和boost中智能指针的关系

C++98中产生了第一个智能指针auto_ptr
boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
C++ TR1引入了shared_ptr等，不过注意的是TR1并不是标准版
C++11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr，并且这些智能指针的实现原理是参考boost中的实现的。