【Happy！1024】C++智能指针

🍎 博客主页：🌙@披星戴月的贾维斯
🍎 欢迎关注：👍点赞🍃收藏🔥留言
🍇系列专栏：🌙 C/C++专栏
🌙请不要相信胜利就像山坡上的蒲公英一样唾手可得，但是请相信，世界上总有一些美好值得我们全力以赴，哪怕粉身碎骨！🌙
🍉一起加油，去追寻、去成为更好的自己！

提示：以下是本篇文章正文内容，下面案例可供参考

---

前言

    先祝所有程序猿1024快乐！！！这次和大家分享一些智能指针的知识以及传值杯的一些有意思的题目，希望大家读了能有所收获！

🍎1.为什么需要智能指针？

    C++这门语言有着悠久的历史，C++有非常多优点，执行效率高，可以直接操作内存和指针， 许多我们现在看到的现象级软件，如windows的部分是C++ 写的，但是C++有一个比较大的缺点就是容易写着写着就内存泄漏了，即使是许多比较优秀的程序猿，如果没有注意，也可能会犯下这个错误，所以就有人去研究了智能指针，来解决这方面的问题。

🍎2.内存泄漏

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

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

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

参考下面代码

void TestMemory()
{
    //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
3
4
5
6
7
8
9
10
11
12
13

2.2 内存泄漏分类
我们主要关心两种方面的内存泄漏：

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

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

2.3如何避免内存泄漏

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

🍎3.智能指针的使用及原理

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

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

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

// 使用RAII思想设计的SmartPtr类
template
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
       : _ptr(ptr)
   {}
    ~SmartPtr()
   {
        if(_ptr)
            delete _ptr;
   }
    
private:
    T* _ptr;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

template
	class SmartPtr
	{
	public:
		// RAII思想
		SmartPtr(T* ptr)
			:_ptr(ptr)
		{}

		~SmartPtr()
		{
			cout <<"delete"<<_ptr << endl;
			//delete[] _ptr;
			delete _ptr;
			_ptr = nullptr;
		}

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

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

		T* Get()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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

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

3.3 std::auto_ptr
std::auto_ptr文档
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原
理

template
	class auto_ptr
	{
	public:
		// RAII思想
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

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

		// sp2(sp1)
		auto_ptr(auto_ptr& sp)
			:_ptr(sp._ptr)
		{
			sp._ptr = nullptr;
		}

		// ...

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

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

		T* get()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

3.4 std::unique_ptr
C++11中开始提供更靠谱的unique_ptr
unique_ptr文档
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原
理

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
template
	class 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;
		}


	//private:
	//	// sp2(sp1)
	//	// C++98
	//	// 1、只声明，不实现
	//	// 2、声明成私有
	//	unique_ptr(const unique_ptr& sp);

		unique_ptr(const unique_ptr& sp) = delete;
		unique_ptr& operator=(const unique_ptr& sp) = delete;

	private:
		T* _ptr;
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

3.5 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
std::shared_ptr文档
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

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

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
template
	class shared_ptr
	{
	public:
		void Release()
		{
			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))
		{}

		~shared_ptr()
		{
			Release();
		}

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

		

		// sp1 = sp3
		shared_ptr& operator=(const shared_ptr& 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;
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

关于shared_ptr的几个问题：

1. shared_ptr智能指针是线程安全的吗？
   是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的。指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了。引用计数的线程安全问题，是智能指针要处理的
2. shared_ptr的线程安全问题（我们留到下节再讲解）

🍎总结

    本文和大家介绍了智能指针相关的几个问题，下节我们详细聊聊shared_ptr的线程安全问题，以及循环引用之类的知识点，希望对大家有所帮助！