【C++11】智能指针

> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：理解在C++11中智能指针，自己能模拟实现 4 种智能指针

> 毒鸡汤：白日莫闲过，青春不再来。

> 专栏选自：C嘎嘎进阶

> 望小伙伴们点赞👍收藏✨加关注哟💕💕

🌟前言

早期在C语言中我们学习了指针，这个指针学起来真是一个头两个大，当然学习到了这里想必大家对指针就不在害怕了，为了填上C++的不足在C++11中就扩展了智能指针，难道智能指针就真的那么智能吗？

⭐主体

学习【C++11】智能指针咱们按照下面的图解：

🌙 智能指针的引入

存在内存泄漏问题：

举个栗子：

#include <iostream>
using namespace std;

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	int* p1 = new int;//p1抛异常，直接跳catch，没有问题
	cout << div() << endl; // div抛异常，调到catch，p1无法释放，资源泄露
	delete p1;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

问题分析：

new空间也有可能会抛出异常，对于p1如果抛出异常：没有问题，可以不管，直接到最外面去了。而如果用户输入的除数为0，那么div函数就会抛出异常，跳到主函数的catch块中执行，但是别忘了，此时Func()中的申请的内存资源还没有释放！

 采用异常的重新捕获： ​​​​​​​

代码重写：

#include <iostream>
using namespace std;

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	int* p1 = new int;//p1抛异常，直接跳catch，没有问题
	try
	{
		cout << div() << endl;
	}
	catch (...)
	{
		delete p1;
		throw;
	}
	delete p1;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

问题分析：

但是如果申请的不是上面的一块空间，而是更多呢，还有p2,p3…？这时候就麻烦了，需要套很多，所以这时候智能指针就登场了，可以解决这个问题。

🌙 内存泄漏

问题再次分析：

C++ 程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。但使用普通指针，容易造成内存泄露（忘记释放）、二次释放、程序发生异常时内存泄露等问题等。所以 C++11 就引入了智能指针。

C 语言中最常使用的是malloc()函数分配内存，free()函数释放内存，而 C++ 中对应的是new、delete关键字。malloc()只是分配了内存，而new则更进一步，不仅分配了内存，还调用了构造函数进行初始化。

总结：

C++11 中引入了智能指针（Smart Pointer），它利用了一种叫做 RAII（资源获取即初始化）的技术将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。这使得智能指针实质是一个对象，行为表现的却像一个指针。

智能指针主要分为shared_ptr、unique_ptr和weak_ptr三种，使用时需要引用头文件。C++98 中还有auto_ptr，基本被淘汰了，不推荐使用。而 C++11 中shared_ptr和weak_ptr都是参考boost库实现的。

🌙 智能指针的使用与原理

💫 智能指针的使用

举个栗子：

#include <iostream>
using namespace std;

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;
	}
	T& operator[](size_t pos)
	{
		return _ptr[pos];
	}
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);
	int* p2 = new int;
	SmartPtr<int> sp2(p2);

	cout << div() << endl;
}
int main()
{
	try
	{
		func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

总结分析：

上面代码将申请到的内存交给了SmartPtr对象管理：

• 在构造SmartPtr对象时，自动调用构造函数，将传入的需要管理的内存保存起来;
• 在析构SmartPtr对象时，自动调用析构函数，将管理的内存空间进行释放
• SmartPtr还可以与普通指针一样使用，需对*和->以及[]进行运算符重载

通过SmartPtr对象，无论程序是正常执行结束，还是因为某些中途原因进行返回，或者抛出异常等开始所面临的困境，只要SmartPtr对象的生命周期结束就会自动调用对应的析构函数，不会造成内存泄漏，完成资源释放。

💫 智能指针的原理

原理讲解：

RAII: RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保存有效，最后在对象析构时释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象，好处：

• 不需要显式地释放资源
• 对象所需的资源在其生命周期内始终保持有效

💫 智能指针拷贝问题

分析：

对于我们上面所实现的SmartPtr，如果用一个SmartPtr对象来拷贝构造另一个SmartPtr对象，或者一个SmartPtr对象赋值给另一个SmartPtr对象，最终结果会导致程序崩溃

举个栗子：

#include <iostream>
using namespace std;

void test()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1);//拷贝构造
	SmartPtr<int> sp3(new int);
	SmartPtr<int> sp4 = sp3;//赋值
}

总结：

编译器默认生成的拷贝构造函数对内置类型完成浅拷贝(值拷贝)，sp1拷贝给sp2后，两个管理同一块空间，当sp1和sp2析构就会让这块内存空间释放两次。同理，编译器默认生成的卡搜被赋值函数对内置类型完成浅拷贝，把sp4赋值给sp3后，sp4与sp3都是管理原来sp3的空间，会析构两次，同时，原先sp4管理的内存没有释放。

单纯的浅拷贝会导致空间多次释放，因为根据智能指针解决卡搜被问题方式不同，所以有很多版本的智能指针。

🌙 auto_ptr指针

💫 auto_ptr指针的使用

概念：

auto_ptr是C++98的，通过管理权转移的方式解决智能指针拷贝问题，保证了一个资源只有一个对象对其进行管理，这时候一个资源就不会被多个释放。

auto_ptr对象具有获取分配给它们的指针的所有权的特殊性：对一个元素拥有所有权的auto_ptr对象负责销毁它所指向的元素，并在销毁自身时解除分配给它的内存。析构函数通过自动调用运算符 delete 来实现此目的。

因此，没有两个auto_ptr对象应该拥有相同的元素，因为两者都会在某个时候尝试破坏它们。当在两个auto_ptr对象之间执行赋值操作时，所有权将转移，这意味着失去所有权的对象将设置为不再指向元素（它设置为空指针）。

举个栗子：

#include <iostream>
using namespace std;

int main()
{
	std::auto_ptr<int> ap1(new int(1));
	std::auto_ptr<int> ap2(ap1);
	*ap2 = 10;
	//*ap1 = 10;错误的写法
	std::auto_ptr<int> ap3(new int(1));
	std::auto_ptr<int> ap4(new int(2));
	ap3 = ap4;
	return 0;
}

分析：

资源的管理权转移意味该对象不能在对原来管理的资源进行访问了，如果进行访问，会导致程序崩溃，很容易出现问题，所以比较少用。

💫 auto_ptr指针的模拟

分析：

构造对象获取资源，析构对象释放资源。对*和->运算符进行重载，使其像指针一样。拷贝构造函数，用传入的对象的资源来构造当前对象，并将传入对象管理资源指针悬空。

代码：

	template<class T>
	class auto_ptr
	{
	public:
		// RAII
		// 保存资源
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		// 释放资源
		~auto_ptr()
		{
			//delete[] _ptr;
			delete _ptr;
			cout << _ptr << endl;
		}

		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			sp._ptr = nullptr;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
	};

🌙 unique_ptr指针

💫 unique_ptr指针的使用

概念：

unique_ptr是C++11中的智能指针，unique_ptr来的更直接：直接防止拷贝的方式解决智能指针的拷贝问题，简单而又粗暴，防止智能指针对象拷贝，保证资源不会被多次释放，但是防止拷贝也不是解决问题的好办法。

举个栗子：

💫 unique_ptr指针的模拟

分析：

构造函数中获取资源，在析构函数中释放资源。对*和->运算符进行重载，使unique_ptr对象具有指针一样的行为。C++98的方式是将拷贝构造函数和拷贝赋值函数声明为私有;C++11的方式就直接在这两个函数后面加上=delete，防止外部进行调用：

代码：

	template<class T>
	class unique_ptr
	{
	public:
		// RAII
		// 保存资源
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		// 释放资源
		~unique_ptr()
		{
			//delete[] _ptr;
			delete _ptr;
			cout << _ptr << endl;
		}

		unique_ptr(const unique_ptr<T>& up) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
	};

🌙 shared_ptr指针

💫 shared_ptr指针的使用

概念：

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

• 每个被管理的资源有有一个对应的引用计数，这个引用计数记录当前有多少对象在管理这块资源。
• 每新增加一个对象管理这块资源则对该资源的引用计数++；当一个对象不在管理这块资源或对象析构时那么该资源对应的引用计数

当一个资源的引用计数为0时那么就说明已经没有对象在管理这块资源了，这时候就可以进行释放了。引用计数的方式能够支持多个对象一起管理一个资源，也就支持智能指针的拷贝，只有当资源的引用计数减为0时才会释放，保证了同一个资源不会被多次释放。

举个栗子：

int main()
{
	std::shared_ptr<int> sp1(new int(1));
	std::shared_ptr<int> sp2(sp1);
	*sp1 = 10;
	*sp2 = 20;
	cout << sp1.use_count() << endl; //2
	//use_count：用于获取当前对象管理的资源对应的引用计数。
	std::shared_ptr<int> sp3(new int(1));
	std::shared_ptr<int> sp4(new int(2));
	sp3 = sp4;
	cout << sp3.use_count() << endl; //2
	return 0;
}

💫 shared_ptr指针的模拟

分析：

shared_ptr每增加一个成员变量pcount,表示只能指针对象管理的资源对应的引用计数。

• 构造函数获取资源时，同时将对应于的引用计数设为1，表示当前一个对象在管理这块资源;析构函数，将管理资源对应的引用计数–,如果为0就需要进行释放
• 拷贝构造函数中，与传入对象一起管理资源，将该资源的引用计数++

对于拷贝赋值：先将当前对象管理的资源对应的引用计数–，为0时需要释放，然后在传入对象一起管理资源。将该资源对应的引用计数++，对*和->进行运算符重载，具有像指针一样的行为。

代码：

	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 保存资源
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// 释放资源
		~shared_ptr()
		{
			Release();
		}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}

		void Release()
		{
			if (--(*_pcount) == 0)
			{
				delete _pcount;
				delete _ptr;
			}
		}
        
        //sp1 = sp1;
        //sp1 = sp2;//sp2如果是sp1的拷贝呢？
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)//资源地址不一样
			{
				Release();
				_pcount = sp._pcount;
				_ptr = sp._ptr;
				++(*_pcount);
			}

			return *this;
		}
        
        int use_count()
		{
			return *_pcount;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	private:
		T* _ptr;
		int* _pcount;
	};

🌙 weak_ptr指针

💫 weak_ptr指针的使用

概念：

weak_ptr是C++11中引入的智能指针，weak_ptr不是用来管理资源的释放的，它主要是用来解决shared_ptr的循环引用问题的。

weak_ptr支持用shared_ptr对象来构造weak_ptr对象，构造出来的weak_ptr对象与shared_ptr对象管理同一个资源，但不会增加这块资源对应的引用计数,解决上述问题。

举个栗子：

    struct ListNode
	{
		std::weak_ptr<ListNode> _prev;
		std::weak_ptr<ListNode> _next;

		~ListNode()
		{
			cout << "~ListNode()" << endl;
		}
	};

	void test_shared_ptr2()
	{
		std::shared_ptr<ListNode> n1 (new ListNode);
		std::shared_ptr<ListNode> n2 (new ListNode);

		n1->_next = n2;
		n2->_prev = n1;

		cout << n1.use_count() << endl;
		cout << n2.use_count() << endl;
	}

分析：

通过use_count获取这两个资源对应的引用计数：结点连接前后这两个资源对应的引用计数就是1，原因是weak_ptr不参与资源管理，不会增加管理的资源对应的引用计数。

💫 weak_ptr指针的模拟

分析：

无参的构造函数；支持用shared_ptr拷贝构造weak_ptr对象，构造时获取shared_ptr对象管理的资源；支持shared_ptr对象拷贝赋值给weak_ptr对象，赋值时获取shared_ptr对象管理的资源，对*和->运算符进行重载，让weak_ptr对象像指针一样具有指针的行为。shared_ptr提供的get函数：用于获取其管理的资源。

代码：

template <class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{

		}
		weak_ptr(const shared_ptr<T>&sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
        T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
        T& operator[](size_t pos)
		{
			return _ptr[pos];
		}
	public:
		T* _ptr;
	};

🌙 性能与安全的权衡

使用智能指针虽然能够解决内存泄漏问题，但是也付出了一定的代价。以shared_ptr举例：

• shared_ptr的大小是原始指针的两倍，因为它的内部有一个原始指针指向资源，同时有个指针指向引用计数。
• 引用计数的内存必须动态分配。虽然一点可以使用make_shared()来避免，但也存在一些情况下不能够使用make_shared()。
• 增加和减小引用计数必须是原子操作，因为可能会有读写操作在不同的线程中同时发生。

🌙C++11与boost中智能指针的关系

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

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

🌙 智能指针模拟代码

// SmartPtr模拟
template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;

		delete _ptr;
	}

	// 像指针一样
	T& operator*()
	{
		return *_ptr;
	}

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

private:
	T* _ptr;
};

namespace lyk
{
	// auto_ptr模拟
	template<class T>
	class auto_ptr
	{
	public:
		// RAII
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		// ap2(ap1)
		auto_ptr(auto_ptr<T>& ap)
		{
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}

		~auto_ptr()
		{
			cout << "delete:" << _ptr << endl;

			delete _ptr;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

	private:
		T* _ptr;
	};

	// unique_ptr模拟
	template<class T>
	class unique_ptr
	{
	public:
		// RAII
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		// ap2(ap1)
		unique_ptr(const unique_ptr<T>& ap) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;

		~unique_ptr()
		{
			cout << "delete:" << _ptr << endl;

			delete _ptr;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

	private:
		T* _ptr;
	};

	// shared_ptr模拟
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			// 拷贝时++计数
			++(*_pcount);
		}

		// sp1 = sp4
		// sp4 = sp4;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)
			{
				release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;

				// 拷贝时++计数
				++(*_pcount);
			}

			return *this;
		}

		void release()
		{
			// 说明最后一个管理对象析构了，可以释放资源了
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			// 析构时，--计数，计数减到0，
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};

	// weak_ptr模拟
	// 不支持RAII，不参与资源管理
	template<class T>
	class weak_ptr
	{
	public:
		// RAII
		weak_ptr()
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
		}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

	private:
		T* _ptr;
	};
}

🌟结束语

       今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。

​​