【c++】：智能指针_智能指针释放

---

一 智能指针是什么

智能指针是一个类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。动态分配的资源，交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源

1.1 为什么要使用智能指针

看下面的代码

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
	{
		throw "除0错误";
	}
	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;

	cout << "delete p1" << endl;
	cout << "delete p2" << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* e)
	{
		cout << e << endl;
	}
	return 0;
}
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

对于以上的由于抛异常导致对象空间没有进行释放而产生的内存泄漏的解决方法就是用智能指针去管理对象资源，由智能指针自动释放对象的资源

二 内存泄漏

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

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

2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)

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

系统资源泄漏：

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

2.3 如何检测内存泄漏

1.在linux下内存泄漏检测
Linux下几款C++程序中的内存泄露检查工具

2. 在windows下使用第三方工具
针对windows平台上C++内存泄漏检测的软件和方法
3.其他工具：
内存泄漏工具比较

2.4如何避免内存泄漏

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

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

内存泄漏检测工具内部原理：申请内存时用一个容器记录下来，释放内存时，从容器中删除掉，程序结束前，或者没有任务运行时，容器中的未删除的资源可能就是内存泄漏。

三 智能指针的使用及原理

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

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

//利用RAII思想设计delete资源的类
template <class T>
class Smartptr
{
public:
	Smartptr(T* ptr)
		:_ptr(ptr)
	{}
	~Smartptr()
	{
		cout << "清理内存" << _ptr << endl;
		delete _ptr;
	}

private:
	T* _ptr;
};


int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
	{
		throw "除0错误";
	}
	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	Smartptr<int> s1(p1);
	Smartptr<int> s2(p2);

	cout << div() << endl;

	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* e)
	{
		cout << e << endl;
	}
	return 0;
}
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

用RAII思想设计一个类去管理资源后，即使出现了在delete资源前抛异常情况，也会由类的对象去自动释放该资，不会产生内存泄漏，但是这种类只是有着RAII的特性，却没有像指针的行为，所以并不是一个智能指针

智能指针的原理：

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

3.1 std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

用法:

头文件: #include < memory >
用 法: auto_ptr<类型> 变量名(new 类型)
1
2

auto_ptr有个巨大的缺陷，就是拷贝的时候他是进行管理权的转移，这种调用后，会导致被拷贝的指向为空，如果再去调用时，就会报错

可以看到这上面的p1和p2调用拷贝后，自己指向的转变成p3,p4指向的，而自己的指向的变为空，产生悬空问题，如果在这之后我们继续使用p1，p2的话，程序就会崩溃，这种方法虽然是使用了智能指针管理资源，但是这里就意思是只能使用一个去管理，所以auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。

auto_ptr的模拟实现

	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete" << _ptr << endl;
				delete _ptr;
			}
		}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{	//管理权的转移
			sp._ptr = nullptr;
		}
		
		auto_ptr<T>& operator=(auto_ptr<T>& sp)
		{
			//检测是不是自己对自己赋值
			if (this == &sp)
			{
				return *this;
			}
			else
			{
				if (_ptr)
				{
					delete _ptr;
				}
				//资源转移
				_ptr = sp._ptr;
				sp._ptr = nullptr;
			}
		}
		//重载*与->实现像指针一样的功能
	    T&	operator *()
		{
			return *_ptr;
		}
		T* operator ->()
		{
			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
47
48
49
50
51
52

auto_ptr 主要有三大问题：

1. 复制和赋值会改变资源的所有权，不符合人的直觉。
2. 在 STL 容器中使用auto_ptr存在重大风险，因为容器内的元素必需支持可复制（copy constructable）和可赋值（assignable）。
3. 不支持对象数组的操作

3.2 std::unique_ptr

c++11中的unique_ptr/shared_ptr/weak_ptr是从boost库中融合过来的

unique_ptr原理：简单粗暴 – 防拷贝 ，不让拷贝只适用于不需要拷贝的一些场景

unique_ptr的部分实现

template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete" << _ptr << endl;
				delete _ptr;
			}
		}
		//防拷贝：c++11写法
		unique_ptr(unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(unique_ptr<T>& sp) = delete;
		
		//重载*与->实现像指针一样的功能
		T& operator *()
		{
			return *_ptr;
		}
		T* operator ->()
		{
			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

3.3 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
如果我们还是需要有拷贝的情况存在，那么unique_ptr就不能使用了，那么就要使用shared_ptr了。shared_ptr 之所以能拷贝，是因为他底层是对资源进行引用计数.

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

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

shared_ptr 的部分实现

	//shared_ptr
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr),
			_count(new int(1))
		{}
		~shared_ptr()
		{
			(*_count)--;
			if (_count == 0)
			{
				delete _ptr;
				delete _count;
			}
		}
		//拷贝构造
		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _count(sp._count)
		{
			(*_count)++;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//自己给自己赋值
			//if (this == &sp)
			if (_ptr == sp._ptr)
			{
				return *this;
			}
			//要先看原来this指向的资源情况，
			//由于this要改变，那么原来指向的资源的_count就要-1
			//且如果-1后this指向的原来的资源的_count为0
			//就需要释放那一部分的资源
			(*_count)--;
			if ((*_count) == 0)
			{
				delete _ptr;
				delete _count;
			}

			//再去将this指向现在赋值的sp指向的资源 
			_ptr = sp._ptr;
			_count = sp._count;
			(*_count)++;
			return *this;
		}


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

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

	private:
		T* _ptr;
		int* _count;
	};
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

shared_ptr的循环引用问题

循环引用分析：

1.node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
4. 也就是说_next析构了，node2就释放了。
5. 也就是说_prev析构了，node1就释放了。
6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

3.4 std::weak_ptr

weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。

对于上面的问题，shared_ptr内部是无法解决的，只能让weak_ptr去帮助解决。
weak_ptr是对对象的一种弱引用，没有RAII，不支持直接管理资源，不参与资源的释放管理，但是能访问和修改资源，不会增加引用计数，就不存在循环引用的问题了。

	//辅助型智能指针，用来配合解决shared_ptr循环引用的问题
	//weak_ptr：简化了很多
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

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

		weak_ptr(const weak_ptr<T>& wp)
			:_ptr(wp._ptr)
		{}

		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;
	};
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

3.5 定制删除器

智能指针采通过引用计数我们能解决多次释放同一块内存空间的问题，并且和之间直接移交管理权的方式比较这种方式更加灵活安全。但是这种方式也只能处理new出来的空间因为new要和析构中的delete匹配，为了使能和new,malloc，fopen的管理空间匹配，我们需要定制删除器

定制删除器能够在构造函数的时候给

//仿函数的定制删除器
struct Node
{
	int val;
	std::shared_ptr<Node> _next;
	std::shared_ptr<Node> _prev;
	~Node()
	{
		cout << "~Node" << endl;
	}
};
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

template<class T>
struct Free
{
	void operator()(T* ptr)
	{
		cout << "free" << ptr << endl;
		free(ptr);
	}
};

//定制删除器
//定制删除器可以用仿函数对象和lambda来进行定义
void Test_shared_ptr3()
{
	// 仿函数对象
	std::shared_ptr<Node> n1(new Node[5], DeleteArray<Node>());
	std::shared_ptr<Node> n2(new Node);

	
	std::shared_ptr<int> n3(new int[5], DeleteArray<int>());
	std::shared_ptr<int> n4((int*)malloc(sizeof(12)), Free<int>());

	//定制删除器也可以使用lambda
	// lambda
	std::shared_ptr<Node> n6(new Node[5], [](Node* ptr){delete[] ptr; });
	std::shared_ptr<Node> n7(new Node);

	std::shared_ptr<int> n8(new int[5], [](int* ptr){delete[] ptr; });
	std::shared_ptr<int> n9((int*)malloc(sizeof(12)), [](int* ptr){free(ptr); });
	
	//用定制删除器能对我们去打开文件进行关闭
	std::shared_ptr<FILE> nn(fopen("test.txt", "w"), [](FILE* ptr){fclose(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

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

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