C++智能指针

Posted 2022-09-30 2021dragon

文章目录

• 智能指针的使用及原理
• • 智能指针的使用
  • 智能指针的原理
• C++中的智能指针
• • std::auto_ptr
  • std::unique_ptr
  • std::shared_ptr
  • • std::shared_ptr的基本设计
    • std::shared_ptr的线程安全问题
    • std::shared_ptr的定制删除器
  • std::weak_ptr
  • • std::shared_ptr的循环引用问题
    • std::weak_ptr解决循环引用问题
• C++11和boost中智能指针的关系

智能指针的使用及原理

智能指针的使用

内存泄露问题

内存泄露是指因为疏忽或错误，造成程序未能释放已经不再使用的内存的情况。比如：

int div()

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

void func()

	int* ptr = new int;
	//...
	cout << div() << endl;
	//...
	delete ptr;

int main()

	try
	
		func();
	
	catch (exception& e)
	
		cout << e.what() << endl;
	
	return 0;

执行上述代码时，如果用户输入的除数为0，那么div函数中就会抛出异常，这时程序的执行流会直接跳转到主函数中的catch块中执行，最终导致func函数中申请的内存资源没有得到释放。

利用异常的重新捕获解决

对于这种情况，我们可以在func函数中先对div函数中抛出的异常进行捕获，捕获后先将之前申请的内存资源释放，然后再将异常重新抛出。比如：

int div()

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

void func()

	int* ptr = new int;
	try
	
		cout << div() << endl;
	
	catch (...)
	
		delete ptr;
		throw;
	
	delete ptr;

int main()

	try
	
		func();
	
	catch (exception& e)
	
		cout << e.what() << endl;
	
	return 0;

利用智能指针解决

上述问题也可以使用智能指针进行解决。比如：

template<class T>
class SmartPtr

public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	
	~SmartPtr()
	
		cout << "delete: " << _ptr << endl;
		delete _ptr;
	
	T& operator*()
	
		return *_ptr;
	
	T* operator->()
	
		return _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> sp(new int);
	//...
	cout << div() << endl;
	//...

int main()

	try
	
		func();
	
	catch (exception& e)
	
		cout << e.what() << endl;
	
	return 0;

代码中将申请到的内存空间交给了一个SmartPtr对象进行管理。

• 在构造SmartPtr对象时，SmartPtr将传入的需要被管理的内存空间保存起来。
• 在SmartPtr对象析构时，SmartPtr的析构函数中会自动将管理的内存空间进行释放。
• 此外，为了让SmartPtr对象能够像原生指针一样使用，还需要对*和->运算符进行重载。

这样一来，无论程序是正常执行完毕返回了，还是因为某些原因中途返回了，或是因为抛异常返回了，只要SmartPtr对象的生命周期结束就会调用其对应的析构函数，进而完成内存资源的释放。

智能指针的原理

智能指针的原理

实现智能指针时需要考虑以下三个方面的问题：

1. 在对象构造时获取资源，在对象析构的时候释放资源，利用对象的生命周期来控制程序资源，即RAII特性。
2. 对*和->运算符进行重载，使得该对象具有像指针一样的行为。
3. 智能指针对象的拷贝问题。

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

为什么要解决智能指针对象的拷贝问题

对于当前实现的SmartPtr类，如果用一个SmartPtr对象来拷贝构造另一个SmartPtr对象，或是将一个SmartPtr对象赋值给另一个SmartPtr对象，都会导致程序崩溃。比如：

int main()

	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1); //拷贝构造

	SmartPtr<int> sp3(new int);
	SmartPtr<int> sp4(new int);
	sp3 = sp4; //拷贝赋值
	
	return 0;

原因如下：

• 编译器默认生成的拷贝构造函数对内置类型完成值拷贝（浅拷贝），因此用sp1拷贝构造sp2后，相当于这sp1和sp2管理了同一块内存空间，当sp1和sp2析构时就会导致这块空间被释放两次。
• 编译器默认生成的拷贝赋值函数对内置类型也是完成值拷贝（浅拷贝），因此将sp4赋值给sp3后，相当于sp3和sp4管理的都是原来sp3管理的空间，当sp3和sp4析构时就会导致这块空间被释放两次，并且还会导致sp4原来管理的空间没有得到释放。

需要注意的是，智能指针就是要模拟原生指针的行为，当我们将一个指针赋值给另一个指针时，目的就是让这两个指针指向同一块内存空间，所以这里本就应该进行浅拷贝，但单纯的浅拷贝又会导致空间被多次释放，因此根据解决智能指针拷贝问题方式的不同，从而衍生出了不同版本的智能指针。

C++中的智能指针

std::auto_ptr

管理权转移

auto_ptr是C++98中引入的智能指针，auto_ptr通过管理权转移的方式解决智能指针的拷贝问题，保证一个资源在任何时刻都只有一个对象在对其进行管理，这时同一个资源就不会被多次释放了。比如：

int main()

	std::auto_ptr<int> ap1(new int(1));
	std::auto_ptr<int> ap2(ap1);
	*ap2 = 10;
	//*ap1 = 20; //error

	std::auto_ptr<int> ap3(new int(1));
	std::auto_ptr<int> ap4(new int(2));
	ap3 = ap4;
	return 0;

但一个对象的管理权转移后也就意味着，该对象不能再用对原来管理的资源进行访问了，否则程序就会崩溃，因此使用auto_ptr之前必须先了解它的机制，否则程序很容易出问题，很多公司也都明确规定了禁止使用auto_ptr。

auto_ptr的模拟实现

简易版的auto_ptr的实现步骤如下：

1. 在构造函数中获取资源，在析构函数中释放资源，利用对象的生命周期来控制资源。
2. 对*和->运算符进行重载，使auto_ptr对象具有指针一样的行为。
3. 在拷贝构造函数中，用传入对象管理的资源来构造当前对象，并将传入对象管理资源的指针置空。
4. 在拷贝赋值函数中，先将当前对象管理的资源释放，然后再接管传入对象管理的资源，最后将传入对象管理资源的指针置空。

代码如下：

namespace cl

	template<class T>
	class auto_ptr
	
	public:
		//RAII
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		
		~auto_ptr()
		
			if (_ptr != nullptr)
			
				cout << "delete: " << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;
			
		
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		
			ap._ptr = nullptr; //管理权转移后ap被置空
		
		auto_ptr& operator=(auto_ptr<T>& ap)
		
			if (this != &ap)
			
				delete _ptr;       //释放自己管理的资源
				_ptr = ap._ptr;    //接管ap对象的资源
				ap._ptr = nullptr; //管理权转移后ap被置空
			
			return *this;
		
		//可以像指针一样使用
		T& operator*()
		
			return *_ptr;
		
		T* operator->()
		
			return _ptr;
		
	private:
		T* _ptr; //管理的资源
	;

std::unique_ptr

防拷贝

unique_ptr是C++11中引入的智能指针，unique_ptr通过防拷贝的方式解决智能指针的拷贝问题，也就是简单粗暴的防止对智能指针对象进行拷贝，这样也能保证资源不会被多次释放。比如：

int main()

	std::unique_ptr<int> up1(new int(0));
	//std::unique_ptr<int> up2(up1); //error
	return 0;

但防拷贝其实也不是一个很好的办法，因为总有一些场景需要进行拷贝。

unique_ptr的模拟实现

简易版的unique_ptr的实现步骤如下：

1. 在构造函数中获取资源，在析构函数中释放资源，利用对象的生命周期来控制资源。
2. 对*和->运算符进行重载，使unique_ptr对象具有指针一样的行为。
3. 用C++98的方式将拷贝构造函数和拷贝赋值函数声明为私有，或者用C++11的方式在这两个函数后面加上=delete，防止外部调用。

代码如下：

namespace cl

	template<class T>
	class unique_ptr
	
	public:
		//RAII
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		
		~unique_ptr()
		
			if (_ptr != nullptr)
			
				cout << "delete: " << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;
			
		
		//可以像指针一样使用
		T& operator*()
		
			return *_ptr;
		
		T* operator->()
		
			return _ptr;
		
		//防拷贝
		unique_ptr(unique_ptr<T>& up) = delete;
		unique_ptr& operator=(unique_ptr<T>& up) = delete;
	private:
		T* _ptr; //管理的资源
	;

std::shared_ptr

std::shared_ptr的基本设计

引用计数

shared_ptr是C++11中引入的智能指针，shared_ptr通过引用计数的方式解决智能指针的拷贝问题。

• 每一个被管理的资源都有一个对应的引用计数，通过这个引用计数记录着当前有多少个对象在管理着这块资源。
• 当新增一个对象管理这块资源时则将该资源对应的引用计数进行++，当一个对象不再管理这块资源或该对象被析构时则将该资源对应的引用计数进行--。
• 当一个资源的引用计数减为0时说明已经没有对象在管理这块资源了，这时就可以将该资源进行释放了。

通过这种引用计数的方式就能支持多个对象一起管理某一个资源，也就是支持了智能指针的拷贝，并且只有当一个资源对应的引用计数减为0时才会释放资源，因此保证了同一个资源不会被释放多次。比如：

int main()

	cl::shared_ptr<int> sp1(new int(1));
	cl::shared_ptr<int> sp2(sp1);
	*sp1 = 10;
	*sp2 = 20;
	cout << sp1.use_count() << endl; //2

	cl::shared_ptr<int> sp3(new int(1));
	cl::shared_ptr<int> sp4(new int(2));
	sp3 = sp4;
	cout << sp3.use_count() << endl; //2
	return 0;

说明一下： use_count成员函数，用于获取当前对象管理的资源对应的引用计数。

shared_ptr的模拟实现

简易版的shared_ptr的实现步骤如下：

1. 在shared_ptr类中增加一个成员变量count，表示智能指针对象管理的资源对应的引用计数。
2. 在构造函数中获取资源，并将该资源对应的引用计数设置为1，表示当前只有一个对象在管理这个资源。
3. 在拷贝构造函数中，与传入对象一起管理它管理的资源，同时将该资源对应的引用计数++。
4. 在拷贝赋值函数中，先将当前对象管理的资源对应的引用计数--（如果减为0则需要释放），然后再与传入对象一起管理它管理的资源，同时需要将该资源对应的引用计数++。
5. 在析构函数中，将管理资源对应的引用计数--，如果减为0则需要将该资源释放。
6. 对*和->运算符进行重载，使shared_ptr对象具有指针一样的行为。

代码如下：

namespace cl

	template<class T>
	class shared_ptr
	
	public:
		//RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		
		~shared_ptr()
		
			if (--(*_pcount) == 0)
			
				if (_ptr != nullptr)
				
					cout << "delete: " << _ptr << endl;
					delete _ptr;
					_ptr = nullptr;
				
				delete _pcount;
				_pcount = nullptr;
			
		
		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		
			(*_pcount)++;
		
		shared_ptr& operator=(shared_ptr<T>& sp)
		
			if (_ptr != sp._ptr) //管理同一块空间的对象之间无需进行赋值操作
			
				if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
				
					cout << "delete: " << _ptr << endl;
					delete _ptr;
					delete _pcount;
				
				_ptr = sp._ptr;       //与sp对象一同管理它的资源
				_pcount = sp._pcount; //获取sp对象管理的资源对应的引用计数
				(*_pcount)++;         //新增一个对象来管理该资源，引用计数++
			
			return *this;
		
		//获取引用计数
		int use_count()
		
			return *_pcount;
		
		//可以像指针一样使用
		T& operator*()
		
			return *_ptr;
		
		T* operator->()
		
			return _ptr;
		
	private:
		T* _ptr;      //管理的资源
		int* _pcount; //管理的资源对应的引用计数
	;

为什么引用计数需要存放在堆区？

首先，shared_ptr中的引用计数count不能单纯的定义成一个int类型的成员变量，因为这就意味着每个shared_ptr对象都有一个自己的count成员变量，而当多个对象要管理同一个资源时，这几个对象应该用到的是同一个引用计数。

如下图：

其次，shared_ptr中的引用计数count也不能定义成一个静态的成员变量，因为静态成员变量是所有类型对象共享的，这会导致管理相同资源的对象和管理不同资源的对象用到的都是同一个引用计数。

如下图：

而如果将shared_ptr中的引用计数count定义成一个指针，当一个资源第一次被管理时就在堆区开辟一块空间用于存储其对应的引用计数，如果有其他对象也想要管理这个资源，那么除了将这个资源给它之外，还需要把这个引用计数也给它。

这时管理同一个资源的多个对象访问到的就是同一个引用计数，而管理不同资源的对象访问到的就是不同的引用计数了，相当于将各个资源与其对应的引用计数进行了绑定。

如下图：

但同时需要注意，由于引用计数的内存空间也是在堆上开辟的，因此当一个资源对应的引用计数减为0时，除了需要将该资源释放，还需要将该资源对应的引用计数的内存空间进行释放。

std::shared_ptr的线程安全问题

shared_ptr的线程安全问题

当前模拟实现的shared_ptr还存在线程安全的问题，由于管理同一个资源的多个对象的引用计数是共享的，因此多个线程可能会同时对同一个引用计数进行自增或自减操作，而自增和自减操作都不是原子操作，因此需要通过加锁来对引用计数进行保护，否则就会导致线程安全问题。

比如下面代码中用一个shared_ptr管理一个整型变量，然后用两个线程分别对这个shared_ptr对象进行1000次拷贝操作，这些对象被拷贝出来后又会立即被销毁。比如：

void func(cl::shared_ptr<int>& sp, size_t n)

	for (size_t i = 0; i < n; i++)
	
		cl::shared_ptr<int> copy(sp);
	

int main()

	cl::shared_ptr<int> p(new int(0));

	const size_t n = 1000;
	thread t1(func, p, n);
	thread t2(func, p, n);

	t1.join();
	t2.join();

	cout << p.use_count() << endl; //预期：1

	return 0;

在这个过程中两个线程会不断对引用计数进行自增和自减操作，理论上最终两个线程执行完毕后引用计数的值应该是1，因为拷贝出来的对象都被销毁了，只剩下最初的shared_ptr对象还在管理这个整型变量，但每次运行程序得到引用计数的值可能都是不一样的，根本原因就是因为对引用计数的自增和自减不是原子操作。

加锁解决线程安全问题

要解决引用计数的线程安全问题，本质就是要让对引用计数的自增和自减操作变成一个原子操作，因此可以对引用计数的操作进行加锁保护，也可以用原子类atomic对引用计数进行封装，这里以加锁为例。

• 在shared_ptr类中新增互斥锁成员变量，为了让管理同一个资源的多个线程访问到的是同一个互斥锁，管理不同资源的线程访问到的是不同的互斥锁，因此互斥锁也需要在堆区创建。
• 在调用拷贝构造函数和拷贝赋值函数时，除了需要将对应的资源和引用计数交给当前对象管理之外，还需要将对应的互斥锁也交给当前对象。
• 当一个资源对应的引用计数减为0时，除了需要将对应的资源和引用计数进行释放，由于互斥锁也是在堆区创建的，因此还需要将对应的互斥锁进行释放。
• 为了简化代码逻辑，可以将拷贝构造函数和拷贝赋值函数中引用计数的自增操作提取出来，封装成AddRef函数，将拷贝赋值函数和析构函数中引用计数的自减操作提取出来，封装成ReleaseRef函数，这样就只需要对AddRef和ReleaseRef函数进行加锁保护即可。

代码如下：

namespace cl

	template<class T>
	class shared_ptr
	
	private:
		//++引用计数
		void AddRef()
		
			_pmutex->lock();
			(*_pcount)++;
			_pmutex->unlock();
		
		//--引用计数
		void ReleaseRef()
		
			_pmutex->lock();
			bool flag = false;
			if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
			
				if (_ptr != nullptr)
				
					cout << "delete: " << _ptr << endl;
					delete _ptr;
					_ptr = nullptr;
				
				delete _pcount;
				_pcount = nullptr;
				flag = true;
			
			_pmutex->unlock();
			if (flag == true)
			
				delete _pmutex;
			
		
	public:
		//RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmutex(new mutex)
		以上是关于C++智能指针的主要内容，如果未能解决你的问题，请参考以下文章
 
 C++ 智能指针 shared_ptr 分析
 C++智能指针的模拟实现
 C++智能指针的模拟实现
 C++智能指针的模拟实现
 C++智能指针的模拟实现
 C++ template —— 智能指针