【C++的智能指针】

于 2025-05-07 09:43:24 发布
阅读量946 收藏 27
点赞数 23
CC 4.0 BY-SA版权
分类专栏： C++学习笔记 文章标签： c++ java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/double__main__/article/details/147724627

【知识预告】

  1. 为什么需要智能指针
  2. 内存泄漏
  3. 智能指针的使用及原理
  4. C++11和boost中智能指针的关系

1 为什么需要智能指针

先看下面的代码：

double Division(int a, int b)
{
	if (b == 0)
	{
		// 抛异常
		throw invalid_argument("Division by zero condition!");
	}
	else
	{
		return (double)a / (double)b;
	}
}

void Func()
{
	int* p = new int[10];

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;

	delete[] p;
	cout << "delete[] " << p << endl;
}

int main()
{
	try 
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

上面的p是不是没有被释放，直接造成了内存泄漏的问题，很严重！！！

2 内存泄漏

2.1 什么是内存泄漏

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

2.2 内存泄漏的危害

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

2.3 内存泄漏分类

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

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

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

2.4 如何避免内存泄漏

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

总结一下：内存泄漏非常常见，解决方案分为两种：

  1. 事前预防型。如智能指针等。
  2. 事后查错型。如泄漏检测工具。

3 智能指针的使用及原理

3.1 RAII

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

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

  1. 不需要显式地释放资源。
  2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。
template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{

	}

	~SmartPtr()
	{
		delete[] _ptr;
		cout << "delete[] " << _ptr << endl;
	}
private:
	T* _ptr;
};

double Division(int a, int b)
{
	if (b == 0)
	{
		// 抛异常
		throw invalid_argument("Division by zero condition!");
	}
	else
	{
		return (double)a / (double)b;
	}
}

void Func()
{
	int* p = new int[10];
	SmartPtr<int> sp(p);

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	try 
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

3.2 智能指针的原理

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

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

	}

	~SmartPtr()
	{
		cout << "~SmartPtr()->" << _ptr << endl;

		delete _ptr;
	}

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

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

void TestSmartPtr1()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 1;

	SmartPtr<pair<string, int>> sp2(new pair<string, int>("xxxx", 1));
	sp2->first += 'y';
	sp2->second += 1;
	sp2.operator->()->second += 1;
}

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

  1. RAII特性。
  2. 重载operator*和opertaor->，具有像指针一样的行为。
void TestSmartPtr2()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2 = sp1;
}

TestSmartPtr2()存在一个问题：对同一快空间，释放了两次！！！

在这里插入图片描述

3.3 auto_ptr

namespace HYQ
{
	// C++98
	// 管理权转移，最后一个拷贝对象管理资源，被拷贝对象都被置空
	// 很多公司都明确规定了，不要用这个
	template<class T>
	class auto_ptr
	{
	public:
		// RAII
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{
		}

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

		// ap2(ap1)   管理权转移
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

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

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

	private:
		T* _ptr;
	};
}

但是又存在以下问题：

void test_auto_ptr1()
{
	HYQ::auto_ptr<int> ap1(new int);
	HYQ::auto_ptr<int> ap2 = ap1;

	// 管理权转移，导致对象悬空
	(*ap1)++;
	(*ap2)++;
}

所以给个结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr

3.4 unique_ptr

对同一块空间释放两次，造成这个问题主要是由于，拷贝和赋值造成的，于是C++11中开始提供更靠谱的unique_ptr。

unique_ptr的实现原理：简单粗暴的防拷贝

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

	}

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

		delete _ptr;
	}

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

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

	// C++11
	unique_ptr(const unique_ptr<T>& up) = delete;
	unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

private:
	// C++98
	// 1、只声明不实现
	// 2、限定为私有
	//unique_ptr(const unique_ptr<T>& up);
	//unique_ptr<T>& operator=(const unique_ptr<T>& up);
private:
	T* _ptr;
};

3.5 shared_ptr

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

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

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
template<class T>
class shared_ptr
{
public:
	// RAII
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pcount(new int(1))
	{

	}

	void release()
	{
		if (--(*_pcount) == 0)
		{
			//cout << "delete->" << _ptr << endl;
			delete _ptr;
			delete _pcount;
		}
	}

	~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 (_ptr != sp._ptr)
		{
			release();

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

			++(*_pcount);
		}

		return *this;
	}

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

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

	int use_count() const
	{
		return *_pcount;
	}

	T* get() const
	{
		return _ptr;
	}

private:
	T* _ptr;
	int* _pcount;
};

3.6 shared_ptr的循环引用

void test_shared_ptr3()
{
	HYQ::shared_ptr<ListNode> n1 = new ListNode;
	HYQ::shared_ptr<ListNode> n2 = new ListNode;

	// 循环引用
	n1->next = n2;
	n2->prev = n1;
}

int main()
{
	test_shared_ptr3();

	return 0;
}

循环引用

解决问题是使用库里面的：weak_ptr。

struct ListNode
{
	int val;
	std::weak_ptr<ListNode> next;
	std::weak_ptr<ListNode> prev;

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

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

	// 循环引用
	n1->next = n2;
	n2->prev = n1;
}

int main()
{
	test_shared_ptr3();

	return 0;
}

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

boost相当于是体验服。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值