【C++】智能指针

一、为什么需要智能指针？

下面我们先分析一下下面这段程序有没有什么内存方面的问题？

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

void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}

int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << 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

答案是：第一个抛异常程序不会出现问题，第二个抛异常会导致p1指向的内存无法释放，第三个异常会导致导致p1，p2指向的内存都无法释放，所以正确的且安全的写法是：

...
void Func()
{
	// 此处抛异常直接跳到main()函数中处理
	int* p1 = new int;
	int* p2 = nullptr;
	try
	{
		// 此处抛异常应该先delete p1 ,然后跳到main()函数中处理
		int* p2 = new int;
	}
	catch (const std::exception& e)
	{
		delete p1;
		throw e;
	}

	try
	{
		// 此处抛异常应该先delete p1, delete p2 ,然后跳到main()函数中处理
		cout << div() << endl;
	}
	catch (const std::exception& e)
	{
		delete p1;
		delete p2;
		throw e;
	}
	delete p1;
	delete p2;
}
...
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

可以看到由于由于异常的原因，导致我们的执行流跳转，可能会导致内存泄漏，这就导致我们要进行多次捕捉，考虑更多的情况，导致我们的代码的可读性很差。

为了解决上面的问题，也为了能更加安全的管理申请到的资源，C++引入了智能指针。

---

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

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

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

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

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

---

二、智能指针的使用及原理

1、RAII

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

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

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

对于上面的代码我们就可以写成这样了

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}
private:
	T* _ptr;
};

...
void Func()
{
	// 如果抛出异常则会先释放资源，再进行跳转。
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);
	cout << div() << endl;
}
...
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

2、智能指针的原理

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

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	// 模拟指针的行为
	T& operator*() 
	{ 
		return *_ptr; 
	}

	T* operator->() 
	{ 
		return _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
17
18
19
20
21
22
23
24
25
26
27
28
29

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

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

3、std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想。

#include 
#include   //智能指针所在的库
int main()
{
	auto_ptr<int> ap1(new int(1));

	// 管理权转移，ap1里面的的指针现在为nullptr，由ap2来进行管理
	auto_ptr<int> ap2(ap1);
	
	// 返回对象里面的指针
	cout << "ap1.get()" << ap1.get() << endl;
	cout << "ap2.get()" << ap2.get() << endl;

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

下面简化模拟实现了一份my::auto_ptr来了解它的原理。

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

	// 拷贝构造
	auto_ptr(auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		_ptr = ap._ptr;
		// 管理权转移
		ap._ptr = nullptr;
	}

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

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

	T* get() const
	{
		return _ptr;	
	}

	~auto_ptr()
	{
		delete _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

auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr，因为指针的拷贝其实是让不同的指针管理同一份资源，而auto_ptr没有做到这一点，以下是这个设计的缺点：

• 所有权转移的隐含副作用：auto_ptr 支持所有权转移，这意味着当一个 auto_ptr 对象所有权被转移时，之前的 auto_ptr 对象将不再有效。这种隐含的副作用使得代码很容易出现错误和难以调试。

• 与标准容器的不兼容性：由于所有权的转移特性，auto_ptr 不能与标准容器（例如 std::vector、std::list 等）一起使用。这是因为标准容器需要能够进行复制和赋值操作，而 auto_ptr 的复制和赋值会导致所有权的转移，破坏了容器的内部结构。

• 不适合多线程环境：auto_ptr 无法正确地处理多线程环境下的资源管理。由于没有明确的所有权转移语义，多个线程可能会同时使用和修改同一个 auto_ptr 对象，导致竞争条件和未定义的行为。

4、std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的禁止拷贝。

下面简化模拟实现了一份unique_ptr来了解它的原理

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

	// 拷贝构造
	unique_ptr(unique_ptr<T>& up) = delete;

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

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

	T* get() const
	{
		return _ptr;
	}

	~unique_ptr()
	{
		delete _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

二、真正的智能指针std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

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

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。

2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。

3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

void test_shared()
{
	shared_ptr<int> sp1(new int(1));

	shared_ptr<int> sp2(sp1);

	// 返回对象里面的指针
	cout << "ap1.get()" << sp1.get() << endl;
	cout << "ap2.get()" << sp2.get() << endl;
}
1
2
3
4
5
6
7
8
9
10

结果符合预期，析构时程序也没有崩溃。

下面我们也来模拟实现一下shared_ptr

template <class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pcount(new int(1))
		,_pmtx(new std::mutex)
	{}


	// 拷贝构造
	shared_ptr(const shared_ptr<T>& sp)
	{
		_pcount = sp._pcount;
		_ptr = sp._ptr;
		_pmtx = sp._pmtx;
		// 增加引用计数
		AddCount();
	}

	// 赋值重载
	const shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		// 拥有相同的资源的对象不允许拷贝
		if (_ptr != sp._ptr)
		{
			// 减少当前资源的引用计数
			Release();
			_ptr = sp._ptr;
			_pcount = sp._pcount;
			_pmtx = sp._pmtx;
			// 增加另一份资源引用计数
			AddCount();
		}
		return *this;
	}

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

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

	T* get() const
	{
		return _ptr;
	}

	int use_count()
	{
		return *_pcount;
	}

	~shared_ptr()
	{
		Release();
	}

private:

	// 每次对引用计数进行修改时都要保证此操作是原子的，便于多线程操作
	void AddCount()
	{
		_pmtx->lock();
		++(*_pcount);
		_pmtx->unlock();
	}

	// 每次对引用计数进行修改时都要保证此操作是原子的，便于多线程操作
	void Release()
	{
		_pmtx->lock();
		int delflag = false;
		// 引用计数为0，且ptr不为空
		if (--(*_pcount) == 0 && _ptr)
		{
			delete _ptr;
			delete _pcount;
			delflag = true;
		}
		_pmtx->unlock();

		// 释放锁
		if (delflag)
		{
			delete _pmtx;
		}
	}

	T* _ptr;
	int* _pcount;
	std::mutex* _pmtx;
};
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

1、std::shared_ptr的线程安全问题

通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、- -是需要加锁的，也就是说引用计数的操作是线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

// shared_safe
struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

void SharePtrFunc(my::shared_ptr<Date>& sp, size_t n)
{
	for (size_t i = 0; i < n; ++i)
	{
		// 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。
		shared_ptr<Date> copy(sp);

		// 这里智能指针访问管理的资源，不是线程安全的。所以我们看看这些两个线程++了2n次，
		// 但是最终看到的结果，并一定是加了2n
		{
			copy->_year++;
			copy->_month++;
			copy->_day++;
		}
	}
}

int main()
{
	shared_ptr<Date> p(new Date);
	cout << p.get() << endl;
	const size_t n = 100000;
	thread t1(SharePtrFunc, std::ref(p), n);
	thread t2(SharePtrFunc, std::ref(p), n);
	t1.join();
	t2.join();
	
	cout << p.use_count() << endl;
	cout << "Date._year :" << p->_year << endl;
	cout << "Date._month :" << p->_month << endl;
	cout << "Date._day :" << p->_day << 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

2、std::shared_ptr的循环引用

虽然shared_ptr智能指针能够帮我们更好的管理资源，但是某些情况下依然会出现资源无法正确的释放。

我们看下面链表进行链接时使用智能指针的问题

// 链表节点
struct ListNode
{
	int _data = 0;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode()
	{
		// 方便我们观察资源有没有释放
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	shared_ptr<ListNode> sp1(new ListNode);
	shared_ptr<ListNode> sp2(new ListNode);

	// 打印引用计数
	cout << "sp1 : " << sp1.use_count() << "    "<<"sp2 : " << sp2.use_count() << endl;

	//开始链接
	sp1->_next = sp2;
	sp2->_prev = sp1;

	// 打印引用计数，此时为1代表正常销毁，不为1代表引用计数出现问题，程序退出以后内存没有释放。
	cout << "sp1 : " << sp1.use_count() << "    " << "sp2 : " << sp2.use_count() << 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

我们来分析一下下面的这段代码：

1. 想要第一个节点销毁，就必须销毁第二个节点中的_prev，使引用计数减少为0。
2. 想要销毁第二个节点中的_prev，必须销毁先第二个节点。
3. 想销毁第二个节点，就必须销毁第一个节点中的_next，使引用计数减少为0。
4. 想要销毁第一个节点中的_next，必须销毁先第一个节点。
5. 重复第一步。

可见其逻辑链形成了一个闭环，导致两个节点相互牵制，都不能正确释放。

造成这个循环引用的原因是节点中的智能指针也参与了节点的管理，导致引用计数的增加，最后无法正确的析构。

如果节点中的指针是一个能够接收shared_ptr类型，指向相应的资源并且又不增加shared_ptr引用计数的的智能指针，那么上面的代码就不会导致出现内存泄漏。

好在，C++标准库中给我们提供了weak_ptr的智能指针，可以做到上述的功能。

3、weak_ptr

特点：

1. 他不是常规的智能指针，不支持RAII。
2. 支持像指针一样。
3. 专门设计出来，辅助解决shared ptr的循环用问题。
4. weak_ptr可以指向资源，但是他不参与管理，不增加引用计数

将上面的节点中的指针更换成weak_ptr就能解决问题。

struct ListNode
{
	int _data = 0;
	
	// 更换成weak_ptr,让节点中的指针不参与管理
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

...
1
2
3
4
5
6
7
8
9
10
11
12
13
14

下面我们来进行weak_ptr的简单模拟实现：

template<class T>
class weak_ptr
{
public:
	// 默认构造
	weak_ptr()
		:_ptr(nullptr)
	{}

	// 拷贝构造
	weak_ptr(const weak_ptr<T>& wp)
		:_ptr(wp._ptr)
	{}

	// 接收shared_ptr的类型
	weak_ptr(const shared_ptr<T>& sp)
		:_ptr(sp.get())
	{}

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

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

	T* get() const
	{
		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

三、定制删除器

刚才我们使用的shared_ptr只能管理new的对象，但是如果我们是new []的对象又该怎么办呢?

为了解决这个问题，C++在shared_ptr的构造函数中增加了一个可调用对象，当shared_ptr释放时会去调用这个可调用对象，这样我们就可以让shared_ptr按照我们的要求进行删除了。

struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

template<class T>
struct DelArray
{
public:
	void operator()(const T* ptr) const
	{
		cout << "delete[] ptr" << endl;
		delete[] ptr;
	}
};

int main()
{
	// 利用定制删除器管理new出来的数组
	shared_ptr<Date> spd(new Date[10], DelArray<Date>());

	// 利用定制删除器管理文件
	shared_ptr<FILE> spf(fopen("a.txt", "w"), [](FILE* fp) {
		cout << "fclose(fp) " << endl;
		fclose(fp);
		});
	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

定制删除器的模拟实现：

我们在原有模拟实现的shared_ptr，上面可以增加一个成员变量用于保存删除器对象，方便我们析构的时候进行使用：

template <class T>
class shared_ptr
{
public:
	...

	template <class D>
	shared_ptr(T* ptr, D del)
		: _ptr(ptr)
		, _pcount(new int(1))
		, _pmtx(new std::mutex)
		, _del(del)
	{}
	...

	~shared_ptr()
	{
		Release();
	}

private:
	void AddCount()
	{
		_pmtx->lock();
		++(*_pcount);
		_pmtx->unlock();
	}

	void Release()
	{
		_pmtx->lock();
		int delflag = false;
		// 引用计数为0，且ptr不为空
		if (--(*_pcount) == 0 && _ptr)
		{
			// 删除时使用可调用对象进行删除
			_del(_ptr);
			delete _pcount;
			delflag = true;
		}
		_pmtx->unlock();

		// 释放锁
		if (delflag)
		{
			delete _pmtx;
		}
	}

	T* _ptr;
	int* _pcount;
	std::mutex* _pmtx;
	// 用包装器来包装可调用对象
	std::function<void(T*)> _del = [](const T* ptr) { delete 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

四、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中的实现的。