C++11: 智能指针

已于 2025-07-04 23:26:25 修改
阅读量917 收藏 8
点赞数 14
CC 4.0 BY-SA版权
文章标签： c++ 智能指针
于 2025-04-06 02:31:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82256131/article/details/147016759

C++11: 智能指针

（一）智能指针原理

我们在编写代码时，会因为各种问题而没有做到内存释放，造成内存泄漏的问题。
即使我们对申请的内存空间记着匹配的去释放，但是如果碰上异常时，就算注意释放了，还是可能会出问题。

因此我们采用RAII思想或者智能指针来管理资源

1.RAll

RAII是什么:

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

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

这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
       : _ptr(ptr)
   {}
    ~SmartPtr()
   {
        if(_ptr)
            delete _ptr;
   }
    
private:
    T* _ptr;
};

2.智能指针

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

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

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

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

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

(二)C++11 智能指针

1. auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。auto_ptr的实现原理：管理权转移的思想。

  • 下面简化模拟实现了一份xrw::auto_ptr来了解它的原理
namespace xrw
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~auto_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

		auto_ptr(const auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			sp._ptr = nullptr;
		}


		auto_ptr& operator=(const auto_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				if (_ptr)
				{
					delete _ptr;
				}

				_ptr = sp._ptr;
				sp._ptr = nullptr;
			}

			return *this;
		}

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

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

实际上，auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。
因为当一个对象的管理权转移后，该对象不能再用对原来管理的资源进行访问，否则程序就会崩溃。

2. unique_ptr

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

下面简化模拟实现unique_ptr

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

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}

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

		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>&sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
	private:
		T* _ptr;
	};
}

该智能指针简单粗暴，但是不能实现拷贝赋值的操作。

3. shared_ptr

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

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

下面是shared_ptr的一个简化的模拟实现

设计思路：
这里提供一个整形指针_count来进行引用计数，当进行拷贝赋值等操作时，我们只需要这个指针的地址拷贝过去，然后将这个指针所指向的内容加1即可。若当进行析构时，对_count所指向的内容减1，并且判断*_count是否等于0，若等于0才真正的进行内存释放

template<class T>
class shared_ptr
{
public:

private:
	T* _ptr;
	int* _count;  //引用计数
};

整体代码：

template<class T>
class shared_ptr
{
private:
	//++引用计数
	void AddRef()
	{
		_pmutex->lock();
		(*_pcount)++;
		_pmutex->unlock();
	}
	//--引用计数
	void ReleaseRef()
	{
		_pmutex->lock();
		bool flag = false;
		if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
		{
			if (_ptr != nullptr)
			{
				cout << "delete: " << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;
			}
			delete _pcount;
			_pcount = nullptr;
			flag = true;
		}
		_pmutex->unlock();
		if (flag == true)
		{
			delete _pmutex;
		}
	}
public:
	//RAII
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pcount(new int(1))
		, _pmutex(new mutex)
	{}
	~shared_ptr()
	{
		ReleaseRef();
	}
	shared_ptr(shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pcount(sp._pcount)
		, _pmutex(sp._pmutex)
	{
		AddRef();
	}
	shared_ptr& operator=(shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr) //管理同一块空间的对象之间无需进行赋值操作
		{
			ReleaseRef();         //将管理的资源对应的引用计数--
			_ptr = sp._ptr;       //与sp对象一同管理它的资源
			_pcount = sp._pcount; //获取sp对象管理的资源对应的引用计数
			_pmutex = sp._pmutex; //获取sp对象管理的资源对应的互斥锁
			AddRef();             //新增一个对象来管理该资源，引用计数++
		}
		return *this;
	}
	//获取引用计数
	int use_count()
	{
		return *_pcount;
	}
	//可以像指针一样使用
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;        //管理的资源
	int* _pcount;   //管理的资源对应的引用计数
	mutex* _pmutex; //管理的资源对应的互斥锁
};

4. weak_ptr

weak_ptr的存在就是为了解决shared_ptr的循坏引用的问题，它能对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& operator= (const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

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

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

（三）shared_ptr中存在的问题

std::shared_ptr的循环引用

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{

	}

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

	}

	weak_ptr& operator= (const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

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

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

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用分析：

  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成员，所以这就叫循环引用，谁也不会释放。
    在这里插入图片描述

那么我们如何解决上面的问题呢？
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

weak_ptr不参与引用计数。

（四）删除器

上面的模拟实现的shared_ptr代码中我们都默认是 new出来的对象通过智能指针管理，但要是不是new出来的对象我们如果处理呢？因此我们引入了一个删除器。

其实删除器的本质和仿函数类似，我们提供一个包装器对象，该对象用来接收（仿函数，lambda表达式等）特等的删除方式。

template<class T>
class shared_ptr
{
public:


private:
	T* _ptr;
	int* _count;
	function <void(T*)> _del = [](T* ptr) {delete ptr; };
};

因此当我们不能只用delete来释放内存的情况出现时，使用shared_ptr智能指针就必须要主动提供一个仿函数（可以是lambda表达式等）来处理删除的情况。

  • 所以我们需要提供一个构造函数来接受这个仿函数
template<class D>
shared_ptr(T* ptr,D del)
	:_ptr(ptr)
	, _count(new int(1))
	,_del(del)
{}

对此删除器我们需要做出改动的就只有析构，拷贝，赋值函数，其实就是将原有的delete，变成调用删除器罢了

~shared_ptr()
{
	if (--(*_count) == 0)
	{
		_del(_ptr);
		delete _count;
	}
}

shared_ptr(const shared_ptr<T>& sp)
	:_ptr(sp._ptr)
	, _count(sp._count)
	, _del(sp._del)
{
	++(*_count);
}

shared_ptr& operator=(const shared_ptr<T>& sp)
{
	if (--(*_count) == 0)
	{
		_del(_ptr);
		delete _count;
	}

	_ptr = sp._ptr;
	_count = sp._count;
	++(*_count);
}

用包装器的思路来处理删除器十分巧妙。

下面是使用这个删除器的例子：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	~A()
	{
		cout << this;
		cout << " ~A()" << endl;
	}
	//private:

	int _a;
};

template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};


int main()
{
	xrw::shared_ptr<A> sp1(new A[10], DeleteArray<A>());
	xrw::shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
	xrw::shared_ptr<A> sp3(new A);  //这里是new一个对象，可以使用默认的delete

	return 0;
}

在这里插入图片描述

（五）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中的实现的。
R_.L
关注
c++：智能指针
make_day_day_up的博客
11-05 3179
智能指针（smart pointer）是一种用来防止内存泄漏的编程技术，它利用对象管理资源的方式（又名RAII——Resource Acquisition Is Initialization），即利用对象析构函数在生命周期结束时自行调用的特性，让编译器自行释放动态开辟的空间。内存泄漏通常发生在使用了new或malloc等函数动态分配内存后，忘记了对应的delete或free调用，或者是因为逻辑错误导致这些调用未能执行。这种情况下，程序占用的内存会逐渐增加，最终可能导致系统资源耗尽，程序崩溃或运行缓慢。
c++学习：智能指针的底层作用原理+用法
weixin_59669309的博客
01-10 622
如果分配了一个内存空间，但后面又忘记释放空间，会造成内存泄漏，智能指针就可以自动释放空间，避免内存泄漏。
C++ 智能指针 C++11
a956365775的博客
07-22 135
一、缘起 C++ 语言没有自动内存回收机制，每次 new 出来的内存都要手动 delete。 程序员忘记 delete，流程太复杂，最终导致没有 delete； 异常导致程序过早退出，没有执行 delete 的情况并不罕见。 用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。 包括：std::auto_ptr、std::shared_ptr、std::weak...
c++11之智能指针
06-01 140
　　在c++98中，智能指针通过一个模板“auto_ptr”来实现，auto_ptr以对象的方式来管理堆分配的内存，在适当的时间（比如析构），释放所获得的内存。这种内存管理的方式只需要程序员将new操作返回的指针作为auto_ptr的初始值即可，程序员不能显式的调用delete。如 auto_ptr(new int)。 　　这在一定程度上避免了堆内存忘记释放造成的问题。不过auto_p...
C++11----智能指针
2403_82706967的博客
05-10 1024
public:SmartPtr(T* ptr) : _ptr(ptr) {} // 构造时获取资源~SmartPtr() { // 析构时释放资源} // 行为像指针private:T* _ptr;// 使用示例：自动释放资源，无需手动deletevoid f() {// 解引用// 指针访问div();// 若抛异常，sp1/sp2/sp4析构时自动释放//浅拷贝问题：SmartPtr未自定义赋值导致内存泄漏sp1 = sp2;
C++11 智能指针（unique_ptr、shared_ptr、weak_ptr）
qq_43169752的博客
10-10 459
很多人怕写 C/C++ 程序就是因为指针，因为指针给了程序员高度的自由，同样也赋予了高度的责任，稍有不慎就导致内存泄漏。其实写 C++ 可以完全不用指针，尤其 C++ 11 对智能指针作了进一步的升级，在不需要使用任何裸指针的前提下也可以写出高效的 C++ 程序。C++ 11 中定义了unique_ptr、shared_ptr与weak_ptr三种智能指针 (smart pointer)，都包含在<memory>头文件中。智能指针可以对动态分配的资源进行管理，保证任何情况下，已构造的对象最终会销
C++11之智能指针（shared_ptr、unique_ptr以及weak_ptr）
Y673582465的专栏
05-30 536
#include <iostream> #include <memory>//c++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被c++11弃用。//为什么要使用智能指针：我们知道c++的内存管理是让很多人头疼的事，当我们写一个new语句时，一般就会立即把delete语句直接也写了， //但是我
C++11中的智能指针
liyucheng777的博客
12-14 1210
无
【C++编程语言】C++11新特性详解：智能指针、右值引用及Lambda表达式在现代C++开发中的应用
最新发布
07-10
内容概要：本文详细介绍了C++11引入的新特性，涵盖自动类型推导（auto）、范围基的for循环、lambda表达式、智能指针、移动语义、初始化列表、静态断言、线程支持、新标准库组件、委托构造函数、显式类型转换、用户...
C++基础（二十二）：智能指针
weixin_47040031的博客
07-15 1140
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
C++进阶：智能指针，写时拷贝技术
凯凯在此
07-12 1699
文章目录1. 智能指针 auto_ptr1.1 auto_ptr的原理1.2 内存检测工具的使用1.3 数组指针的释放1.4 赋值操作的问题2. 智能指针 unique_ptr3. 智能指针 scoped_ptr4. 智能指针 shared_ptr4.1 shared_ptr的原理4.2 数组指针的释放5. 智能指针 weak_ptr 指针的危害 指针未初始化 野指针 内存泄漏 1. 智能指针 auto_ptr 1.1 auto_ptr的原理 作用： 对作用域内的动态分配对象的自动释放 #inclu
C++11——智能指针
weixin_57023347的博客
10-30 3100
前言 由于C++没有GC(垃圾回收器)，程序员从堆上申请的资源，打开的文件，创建的套接字需要我们手动释放和关闭。 但是可能会出现两个问题： 异常安全问题。申请完资源，由于异常需要捕捉，使得执行流不会按顺序进行，导致资源还没有释放和关闭，就跳到别的地方执行了。 由于需要程序员手动释放和关闭，可能会有忘记释放和关闭的问题。 这样就会导致资源的泄漏。计算机的资源是有限的，导致我们可以使用的资源越来越少。 智能指针是针对我们从堆上申请的空间，...
C++11：智能指针
qq_45303986的博客
10-30 1052
为什么要用智能指针方便和安全的使用动态内存智能指针的行为类似于常规指针智能指针的作用：智能指针可以在适当时机自动释放分配的内存，可以很好地避免“忘记释放内存而导致内存泄漏”问题。
C++11:智能指针
weixin_30716141的博客
09-06 171
一.简介 C++ 中动态内存的管理是通过 new 和 delete 来配对使用。但是我们可能存在忘记释放内存的情况，为了更好的托管动态内存，C++11 提供了两种智能指针类型来管理动态对象 shared_ptr 允许多个指针指向同一个对象，weak_ptr 类指向 shared_ptr 所管理的对象 unique_ptr 独占所指向的对象 都定义在 memory 头文...
C++进阶：智能指针与线程池解析
- C++智能指针的主要目标是解决手动管理堆内存的问题，如内存泄露和双重释放。C++11引入了智能指针，包括`auto_ptr`(已被弃用)，`unique_ptr`, `shared_ptr`, 和`weak_ptr`。 - **shared_ptr** 是一个共享所有权的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值