C++智能指针-保姆级讲解带你一文搞懂智能指针（附核心代码实现+讲解）

1.引言

1.1 为什么会出现智能指针

C++中引入智能指针的主要目的是为了解决动态内存管理的问题（C++不像Java等语言有垃圾回收机制 C+对性能要求极高，所以没有垃圾碎片回收机制，对于内存的释放要特别小心）。传统的指针（裸指针）在使用时需要手动分配和释放内存，容易出现内存泄漏和悬挂指针等问题。智能指针通过封装裸指针，并提供自动内存管理功能，使得内存资源可以更安全、高效地管理。
智能指针具有以下优点：

1. 自动内存管理：智能指针使用了RAII（资源获取即初始化）的原则，即在构造函数中获取资源，在析构函数中释放资源。这样可以确保资源的正确释放，避免内存泄漏。

2. 所有权管理：智能指针可以跟踪动态分配的内存资源的所有权，确保只有一个智能指针拥有该资源。当所有智能指针超出作用域或被重新赋值时，会自动释放内存，避免出现悬挂指针和内存访问错误。

3. 共享所有权：某些智能指针（如std::shared_ptr）允许多个指针共享同一块内存资源，当所有共享指针超出作用域时，才会释放内存。这样可以有效地管理资源的共享和释放，避免出现资源被提前释放或多次释放的问题。

4. 防止空悬指针：智能指针在初始化时会进行空指针检查，避免了访问空指针导致的程序崩溃或未定义行为。

5. 提高代码可读性和维护性：使用智能指针可以简化内存管理的代码逻辑，减少手动内存释放的疏忽和错误。同时，智能指针的语义清晰，可以更好地表达程序的意图，提高代码的可读性和维护性。

总之，智能指针是C++中一种重要的工具，它提供了更安全、高效的内存管理方式，帮助程序员避免了很多与内存管理相关的问题。通过使用智能指针，可以简化代码、提高可靠性，并减少内存泄漏等问题的发生。

1.2内存泄漏

1.2.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而
造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会
导致响应越来越慢，最终卡死

void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}

1.2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。系统资源泄漏指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

1.2.3如何检测内存泄漏

• 在linux下内存泄漏检测： linux下几款内存泄漏检测工具链接
• 在windows下使用第三方工具： VLD工具说明链接
• 其他工具： 内存泄漏工具比较链接

1.2.4如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

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

2. 智能指针的使用及原理

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

• 一个简单的智能指针

#pragma once
#include<iostream>
namespace GXPYY
{
	template<class T>
	class smartptr
	{
	public:
		smartptr(T* ptr = nullptr)
			:_ptr(ptr)
		{};
		~smartptr()
		{
			cout << "ptr delet..." << endl;
			if (_ptr)
				delete _ptr;

		}

	private:
		T* _ptr;
	};

}

• 测试+运行
  
  可见 当指针sp1234生命周期结束时，智能指针就会把相关的资源释放，避免内存泄漏，下面将赋值操作完善一下。

#pragma once
#include<iostream>
namespace GXPYY
{
	template<class T>
	class smartptr
	{
	public:
		smartptr(T* ptr = nullptr)
			:_ptr(ptr)
		{};

		~smartptr()
		{
			cout << "ptr delet..." << endl;
			if (_ptr)
				delete _ptr;

		}

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

		//针对map类型对象可以进行-》访问
		T* operator->()
		{
			return _ptr;
		}


	private:
		T* _ptr;
	};

}

• 结果：
  
  这样一个简单的智能指针完成啦
  思考一个问题：拷贝怎么实现？拷贝问题是智能指针的难点！！！！

3.常见智能指针

3.1std::auto_ptr

std::auto_ptr是C++98标准中提供的智能指针，它是独占式智能指针，用于管理动态分配的对象。它通过在对象析构时自动释放内存来解决资源管理的问题。

• 核心代码逻辑

	//拷贝构造
		//auto_ptr
		smartptr(smartptr <T>& ptr)
			:_ptr (ptr._ptr)
		{
			ptr._ptr = nullptr;
		}

通过调试窗口可以发现，再完成拷贝之后，sp3被重置为0x000了，也就是悬空指针！

再对sp3进行操作时候就会出现异常！悬空指针不能再进行操作。
所以可以总结一下：auto_ptr的核心思想就是–控制权转移。
由于它弊端比较拉跨，我们一般不会使用它作为智能指针！
它是c+98的产物，可以理解为是c+发展过程中的实验品。

3.2std::unique_ptr

std::unique_ptr是C++11标准引入的智能指针，其核心思想是独占所有权（exclusive ownership）和资源管理的责任。

核心思想可以总结为以下几点：

• 独占所有权：std::unique_ptr独占所管理的指针资源，同一时间只能有一个std::unique_ptr拥有该资源。当std::unique_ptr被销毁或转移所有权时，它会自动释放所管理的资源，确保资源在适当的时候被正确释放，避免资源泄漏。

• 确保资源的释放：std::unique_ptr通过在析构函数中自动调用delete来释放所管理的资源。这意味着，无论是通过正常的控制流还是异常的控制流，只要std::unique_ptr被销毁，资源都会得到释放，避免了手动释放资源的繁琐和可能的遗漏。

• 禁止拷贝：std::unique_ptr禁止拷贝构造函数和拷贝赋值运算符的使用，以确保同一时间只有一个std::unique_ptr拥有资源的所有权。这样可以防止多个智能指针同时管理同一块资源，避免了资源的重复释放和悬挂指针的问题。

• 支持移动语义：std::unique_ptr支持移动构造函数和移动赋值运算符，允许资源的所有权从一个std::unique_ptr对象转移到另一个对象，避免了资源的不必要拷贝。

总的来说，std::unique_ptr的核心思想是通过独占所有权和自动释放资源的方式，提供了一种安全、高效的资源管理机制，减少了手动管理资源的复杂性和错误，并支持现代C++中的移动语义。

可以看到，**unique_ptr对于拷贝构造的处理机制就是----->禁止拷贝！**简单粗暴

• 核心代码逻辑：

public:
		// RAII思想
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete" << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;
			}
		}

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

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

		T* get()
		{
			return _ptr;
		}

不通过拷贝构造实现！

3.3std::share_ptr

std::shared_ptr是C++11标准引入的智能指针，其核心思想是共享所有权（shared ownership）和引用计数。

核心思想可以总结为以下几点：

1. 共享所有权：std::shared_ptr可以与其他std::shared_ptr共享对同一块资源的所有权。多个std::shared_ptr可以指向同一个对象，它们共同管理对象的生命周期。当所有std::shared_ptr都离开作用域或被显式销毁时，资源才会被释放。

2. 引用计数：std::shared_ptr内部维护了一个引用计数器，用于跟踪有多少个std::shared_ptr对象共享对资源的所有权。每当创建一个std::shared_ptr对象时，引用计数会加一；当std::shared_ptr对象被销毁时，引用计数会减一。只有当引用计数为零时，资源才会被释放。

3. 自动内存管理：std::shared_ptr通过在析构函数中检查引用计数，当引用计数为零时，自动释放所管理的资源。这样，无需手动释放资源，避免了资源泄漏。

4. 拷贝和赋值：std::shared_ptr支持拷贝构造函数和拷贝赋值运算符，允许多个std::shared_ptr对象共享对同一资源的所有权。拷贝一std::shared_ptr会增加引用计数，销毁一个std::shared_ptr会减少引用计数。

5. 循环引用的解决：std::shared_ptr通过使用弱引用（std::weak_ptr）来解决循环引用的问题。弱引用不会增加引用计数，可以监视std::shared_ptr对象的生命周期，避免循环引用导致的资源泄漏。

对于拷贝构造 share_ptr引用了一个计数器

• 核心代码逻辑

template<class T>
	class shared_ptr
	{
	public:
		void Release()
		{
			//析构一次 pcount--
			//当计数器==0时且ptr存在才释放资源
			if (--(*_pCount) == 0 && _ptr)
			{
				cout << "delete" << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;

				delete _pCount;
				_pCount = nullptr;
			}
		}

		// RAII思想
		shared_ptr(T* ptr )
			:_ptr(ptr)
			, _pCount(new int(1))//构造的时候把pcount赋值1
		{}

		~shared_ptr()
		{
			Release();
		}

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



		// sp1 = sp3
		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;
		}
		T& operator*()
		{
			return *_ptr;
		}

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

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

• 调试
  
  可见 拷贝之后，sp4 和sp3指向同一块内存，而且pcount计数器++为2了，那么我们试着去析构一下看看怎么样。
  
  可见 析构之后并不会去直接释放资源，而是对相应的pcount–；

关于share_ptr的补充

链接: weak_ptr+share_ptr 配合使用

定制删除器

链接: 定制删除器