【C++】auto_ptr为何被唾弃？以及其他智能指针的学习

最新推荐文章于 2025-05-26 22:45:00 发布

原创

最新推荐文章于 2025-05-26 22:45:00 发布 · 1.7k 阅读

44 ·

CC 4.0 BY-SA版权

文章标签：

#C++11 #后端 #智能指针 #visualstudio #c++ #内存管理 #RAII

本文介绍了C++中智能指针的作用，特别是如何使用它们来防止内存泄漏。通过示例代码展示了`auto_ptr`、`unique_ptr`、`shared_ptr`和`weak_ptr`的实现和使用，强调了`shared_ptr`的线程安全性和循环引用问题，以及如何利用`weak_ptr`解决循环引用导致的内存泄漏。文章还讨论了资源管理策略，如RAII原则，并提到了定制删除器的概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

搭配异常可以让异常的代码更简洁

文章目录

智能指针
内存泄漏的危害
1.auto_ptr(非常不建议使用)
2.unique_ptr
3.shared_ptr
4.weak_ptr
总结

智能指针

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

在上面的代码中，一旦出现异常那就会造成内存泄漏，什么是内存泄漏呢：

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内

存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对

该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现

内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏分类：

堆内存泄漏 (Heap leak)

堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new 等从堆中分配的一

块内存，用完后必须通过调用相应的 free 或者 delete 删掉。假设程序的设计错误导致这部分

内存没有被释放，那么以后这部分空间将无法再被使用，就会产生 Heap Leak 。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放

掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如果func函数里的p1new的时候抛异常该怎么办呢？对于第一个new如果抛异常会直接跳到main函数中的catch被捕获，那么p2new失败了会怎么办呢？div函数抛异常我们可以捕获一下：

那么如果是p2失败了我们还要再catch一下：

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

那么这样的代码看起来会不会有些冗余呢？为了处理这样的问题，智能指针就能起到很好的作用：

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

	}
	~SmartPtr()
	{
		delete _ptr;
		cout << _ptr << endl;
	}
private:
	T* _ptr;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	int* p1 = new int;
	SmartPtr<int> sp1(p1);
	int* p2 = new int;
	SmartPtr<int> sp2(p2);
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

可以看到有了智能指针即使抛异常了我们没有释放的空间也会被自动释放，因为抛异常后自定义类型出了作用域我们智能指针的析构函数会将这个空间释放。当然，我们的智能指针也可以直接创建资源，比如下面这样：

但是我们这样写不就不可以对指针解引用访问指针的资源了吗？其实我们只需要再给智能指针多加加个功能让它变得像指针一样就解决了这个问题：

template <class T>
class SmartPtr
{
public:
	//保存资源
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{

	}
	//释放资源
	~SmartPtr()
	{
		delete _ptr;
		cout << _ptr << endl;
	}
	//像指针一样
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator[](size_t pos)
	{
		return _ptr[pos];
	}
private:
	T* _ptr;
};

这个时候我们来使用一下这个指针：