【C++】智能指针

最新推荐文章于 2024-10-05 21:10:28 发布
最新推荐文章于 2024-10-05 21:10:28 发布
阅读量281 收藏 4
点赞数 7
分类专栏： C++的修行之路 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c0631xjn_/article/details/132817707
版权

文章目录

1. RAII

💭智能指针是用以资源管理的一种工具。所谓资源就是，一旦用了它，将来就必须还给系统。如果不这样的话，会发生糟糕的事，如内存泄漏。C++程序中最常见的资源就是动态分配的内存（new/malloc申请堆上的内存，delete/free释放，如果不释放会导致内存泄漏）。谨慎地编写程序能让我们避免大部分不将资源还给系统的情况，但还是会有一些情况是难以避免的，举两个例子：

⭕情况1：func1()中，因为抛异常而未能执行语句delete[] pArray，资源未释放

void func1()
{
	int* pArray = new int[10];

	// to do something...
	throw("error");

	delete[] pArray;
}

int main()
{
	try
	{
		func1();
	}
	catch (const char* errmsg)
	{
	}

	return 0;
}

⭕情况2：函数内多重回传路径

void func1(int x)
{
	int* pArray = new int[10];

	if (x > 0)
	{
		return;
	}
	else
	{
		std::cout << x << std::endl;
	}

	delete[] pArray;
}

int main()
{
	int x = 0;
	func1(x);

	return 0;
}

事实上，内存只是你管理的众多资源之一。其它资源如：打开的文件描述符(File Describtors)、互斥量(Mutex)、网络sockets等在使用后都需要归还给系统。而仅仅让程序员谨慎代码是很难完全规避内存泄漏的问题的。

  • RAII思想

    RAII(Resource Acquisiton Is Initialization)，是一种利用对象的生命周期管理资源的方法，即“资源取得时机便是初始化时机”。每一笔资源在被获取到时，立刻被放入管理对象中。而管理对象运用析构函数确保资源被释放。也就是说，无论执行流以任何形式离开当前区块，一旦管理对象被销毁，生命周期结束，既调用管理对象的析构函数，而析构函数中包含了对象管理的资源的释放方法，这样就能保证资源被释放了。

  • RAII的优势

    1. 不需要显式地释放资源
    2. 对象管理的资源在其生命周期内有效

而智能指针正是运用了RAII思想，对资源进行管理的一种对象。

2. 智能指针

智能指针，顾名思义，除了能够以RAII思想管理资源外，还要能够像原生指针一样使用，既通过*和->访问管理资源，在C++类中可通过运算符重载实现。而智能指针真正的难点在于拷贝问题，不同的智能指针实现对拷贝问题有不同的解决方法。

🔎下面介绍C++标准库中三种智能指针：

头文件：#include <memory>

auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针，下面演示auto_ptr的模拟实现。

拷贝问题解决方法：资源管理权的交换

在这里插入图片描述

auto_ptr模拟实现

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

        // 拷贝构造，直接取ap的指针，并将ap指针设为空
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

        // 赋值重载
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			//交换资源管理权，即交换指针
			std::swap(ap._ptr, _ptr);
			return *this;
		}

		~auto_ptr()
		{
            // 析构时释放资源
			if (_ptr)
				delete _ptr;
		}

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

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

	private:
		T* _ptr; // 指针管理资源
	};
}

⭕auto_ptr的缺陷：

  1. 多个auto_ptr无法指向同一资源的问题。（若多个auto_ptr指向同一资源，资源会被删除多次，这是错误的）
  2. 频繁交换资源管理权，会导致auto_ptr的指向不明确。

综上所述，auto_ptr是一个失败的设计。

unique_ptr

C++11库中给出的更靠谱的unique_ptr

拷贝问题解决方法：简单粗暴的禁止拷贝

unique_ptr模拟实现

namespace ckf
{
	template <class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
        
        // 删除拷贝构造和赋值重载函数
		unique_ptr(const unique_ptr& up) = delete;
		unique_ptr<T>& operator=(const unique_ptr& up) = delete;

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

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

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

	private:
		T* _ptr;
	};
}

⭕unique_ptr的缺陷：

​ 比起auto_ptr，指针的指向非常明确，但依然无法解决多个指针资源共享的问题。

shared_ptr

C++11中的shared_ptr完美解决了以上两个智能指针的问题。

拷贝问题解决方法：引用计数

在这里插入图片描述

  • shared_ptr模拟实现
namespace ckf
{
	// 1. RAII
	// 2. like pointer
	// 3. copy

	template <class T>
	class shared_ptr
	{
		typedef shared_ptr<T> Self;
	public:

		T& operator*()
		{
			assert(_pdata);
			return *_pdata;
		}

		T* operator->()
		{
			assert(_pdata);
			return _pdata;
		}


		// constructor
		shared_ptr(T* pdata = nullptr)
			:_pdata(pdata)
		{
			if (_pdata)
			{
				_pcount = new int(1);
				_pmtx = new std::mutex;
			}
			else
			{
                // 若指向资源为空，则计数器和互斥量也为空
				_pcount = nullptr;
				_pmtx = nullptr;
			}
		}

		// destructor
		~shared_ptr()
		{
            // release先对计数器减1，再检查计数器是否为0，为0则释放资源
			release();
		}

		// copy
		shared_ptr(const Self& sp)
			:_pdata(sp._pdata)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			if(_pdata)
				add_count();
		}

		// operator=
		Self& operator=(const Self& sp)
		{
			// 相同就不用赋值了
			if (_pdata != sp._pdata)
			{
				release();

				_pdata = sp._pdata;
				_pcount = sp._pcount;
				_pmtx = sp._pmtx;
				
				if (_pdata)
					add_count();
			}

			return *this;
		}
		
        // 获取计数器内容（指向为空返回0）
		int use_count() const
		{
			if (_pdata)
				return *_pcount;
			else
				return 0;
		}

		T* get() const
		{
			return _pdata;
		}

	private:

		void release()
		{
			if (_pdata) // 若为空，什么也不做
			{
                // 访问计数器，需要加锁保护
				_pmtx->lock();

				bool deleteFlag = false;

				// 计数器减到0，即释放资源
				if (--(*_pcount) == 0)
				{
					delete _pdata;
					delete _pcount;
					deleteFlag = true;
				}

				_pmtx->unlock();
				if (deleteFlag) // 资源释放，锁才释放
					delete _pmtx;
			}
		}

		void add_count()
		{
            // 访问计数器，需要加锁保护
			_pmtx->lock();

			++(*_pcount);

			_pmtx->unlock();
		}

		T* _pdata;
		int* _pcount;
		std::mutex* _pmtx;
	};

	// 多线程可能会使用同一个shared_ptr(包括它的拷贝)
	// 因此
	// 对于计数器的访问，应该由shared_ptr保证线程安全
	// 对于sp指向数据，应该由用户自行保证数据安全
}
  • shared_ptr赋值的过程：

在这里插入图片描述

  • shared_ptr线程安全的测试demo
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
using namespace std;

class Date
{
public:
	Date(int year = 2023, int month = 9, int day = 7)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	~Date()
	{
		std::cout << "~Date()" << std::endl;
	}

	void getDate()
	{
		printf("%d年%d月%d日\n", _year, _month, _day);
	}

	int _year;
	int _month;
	int _day;
};

void SmartPtrTest(ckf::shared_ptr<Date>& sp, const int& n, std::mutex& mtx)
{
	// 测试ckf::shared_ptr的线程安全
	for (int i = 0; i < n; i++)
	{
		// 这里两个线程不断拷贝sp和释放sp，既不断对sp计数器的++和--，最终保证sp计数器为1
		ckf::shared_ptr<Date> copy(sp);

		// 管理资源的安全由程序员保证
		// 若对资源的访问是线程安全的
		// 那么两个线程执行后三个值应该都是20000
		mtx.lock();

		copy->_year++;
		copy->_month++;
		copy->_day++;

		mtx.unlock();
	}

	//这里出现2的原因：
	//可能是另外一个线程正处于for循环中创建copy和销毁copy的间隙
	//此时计数器为2
	//线程调度到当前线程，use_count()打印的数就是2
	//但是不影响最终计数器依旧为1
	//std::cout << sp.get() << " " << sp.use_count() << std::endl;
}

void test_thread_safe()
{
	ckf::shared_ptr<Date> sp(new Date(0, 0, 0));
	const int n = 100000;
	std::mutex mtx;

	// 观察多线程执行前后，sp计数器是否依然为1
	cout << "before: " << sp.use_count() << endl;
	sp->getDate();
	cout << endl;

	std::thread t1(SmartPtrTest, std::ref(sp), n, std::ref(mtx));
	std::thread t2(SmartPtrTest, std::ref(sp), n, std::ref(mtx));
	std::this_thread::sleep_for(std::chrono::seconds(1));

	cout << "after: " << sp.use_count() << endl;
	sp->getDate();
	cout << endl;

	t1.join();
	t2.join();
}

int main()
{
	test_thread_safe();
	return 0;
}

⭕运行结果

在这里插入图片描述

  • 删除器deleter

有时候，单单的delete ptr无法满足释放资源的需求。就如：管理的资源是以new T[]形式开辟的，则需delete[]释放；又如：管理的资源是C语言打开文件的FILE结构体，那么需要fclose()函数释放。标准库中的shared_ptr配套了删除器，用于指定某种释放资源的方式。

在这里插入图片描述

使用方法如下：

void test_deleter()
{
    // 事实上deleter就是一个可调用对象，这里用了lambda表达式
	std::shared_ptr<Date> sp1(new Date[10], [](Date* ptr) {delete[] ptr; });
	std::shared_ptr<FILE> sp2(fopen("log.txt", "w"), [](FILE* fp) {fclose(fp); });
}

shared_ptr with deleter

namespace ckf
{
	// 1. RAII
	// 2. like pointer
	// 3. copy

	template <class T>
	class shared_ptr
	{
		typedef shared_ptr<T> Self;
	public:

		T& operator*()
		{
			assert(_pdata);
			return *_pdata;
		}

		T* operator->()
		{
			assert(_pdata);
			return _pdata;
		}


		// constructor
		shared_ptr(T* pdata = nullptr)
			:_pdata(pdata)
		{
			if (_pdata)
			{
				_pcount = new int(1);
				_pmtx = new std::mutex;
			}
			else
			{
				_pcount = nullptr;
				_pmtx = nullptr;
			}
		}
		
        // 增加一个构造函数，可自动推导deleter类型
		template <class D>
		shared_ptr(T* pdata, D del)
			:_pdata(pdata)
			,_del(del)
		{
			if (_pdata)
			{
				_pcount = new int(1);
				_pmtx = new std::mutex;
			}
			else
			{
				_pcount = nullptr;
				_pmtx = nullptr;
			}
		}

		// destructor
		~shared_ptr()
		{
			release();
		}
		
        // deleter也要拷贝
		// copy
		shared_ptr(const Self& sp)
			:_pdata(sp._pdata)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
			, _del(sp._del)
		{
			if(_pdata)
				add_count();
		}

		// operator=
		Self& operator=(const Self& sp)
		{
			// 相同就不用赋值了
			if (_pdata != sp._pdata)
			{
				release();

				_pdata = sp._pdata;
				_pcount = sp._pcount;
				_pmtx = sp._pmtx;
				_del = sp._del;
				
				if (_pdata)
					add_count();
			}

			return *this;
		}

		int use_count() const
		{
			if (_pdata)
				return *_pcount;
			else
				return 0;
		}

		T* get() const
		{
			return _pdata;
		}

	private:

		void release()
		{
			if (_pdata) // 若为空，什么也不做
			{
				_pmtx->lock();

				bool deleteFlag = false;

				// sp为空或者减计数到0，即释放空间
				if (--(*_pcount) == 0)
				{
					//delete _pdata;
					_del(_pdata);
					delete _pcount;
					deleteFlag = true;
				}

				_pmtx->unlock();
				if (deleteFlag)
					delete _pmtx;
			}
		}

		void add_count()
		{
			_pmtx->lock();

			++(*_pcount);

			_pmtx->unlock();
		}

		T* _pdata;
		int* _pcount;
		std::mutex* _pmtx;
		std::function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}

⭕shared_ptr的缺陷：

shared_ptr是较为靠谱的一种智能指针，但是会有一个小问题——循环引用。看下面代码：

struct Node
{
	ckf::shared_ptr<Node> _next;
	ckf::shared_ptr<Node> _prev;

	Node(int val) :_val(val)
	{}

	~Node()
	{
		std::cout << _val << "~Node()" << std::endl;
	}
    
    int _val = 0;
};

void test_cycle_ref()
{
	ckf::shared_ptr<Node> n1(new Node(1));
	ckf::shared_ptr<Node> n2(new Node(2));

	n1->_next = n2;
	n2->_prev = n1;
}

int main()
{
    test_cycle_ref();
    return 0;
}

📑演示图：

在这里插入图片描述

流程分析：

  1. n1和n2两个shared_ptr分别指向节点1和节点2，以RAII方式管理资源。此时两个节点的计数器都为1。
  2. 两个节点中的_next和_prev也是shared_ptr，节点1的_next指向节点2，节点2的_prev指向节点1。此时两个节点的计数器都增加为2。
  3. 函数执行完毕，先销毁n2——节点2的计数器减为1（节点1中的_next还指向节点2），再销毁n1——节点1的计数器减为1（节点2的_prev还指向节点1）。
  4. 此时陷入了僵局。只有_next析构了，节点2才能释放，只有_prev析构了，节点1才能释放。根据类的特性，节点1释放，_next才会析构，节点2释放，_prev才会析构。二者的释放条件依赖于彼此，谁也不释放，这就是循环引用。（节点1释放要2.prev析构->2.prev析构要节点2释放->节点2释放要1.next析构->1.next析构要节点1释放，形成闭环）

解决方法：

C++11中引进了weak_ptr智能指针。该类型指针通常不单独使用，只能和 shared_ptr搭配使用来解决循环引用问题。

  1. weak_ptr并不参与资源的管理，只是作为shared_ptr的辅助，与shared_ptr指向相同的资源，不会修改所管理资源配套的计数器。
  2. weak_ptr没有重载*和->运算符，这意味着weak_ptr只能指向内存空间，主要用于保存或赋予指针给shared_ptr，无法访问修改内存空间。
  3. weak_ptr也有引用计数，但只用于查看与该weak_ptr指向相同的shared_ptr的数量。引用计数为0时，weak_ptr处于过期状态。
struct Node
{
	int _val = 0;
	std::weak_ptr<Node> _next;
	std::weak_ptr<Node> _prev;

	Node(int val) :_val(val)
	{}

	~Node()
	{
		std::cout << _val << "~Node()" << std::endl;
	}
};

void test_cycle_ref()
{
	std::shared_ptr<Node> n1(new Node(1));
	std::shared_ptr<Node> n2(new Node(2));

    // weak_ptr可以接收shared_ptr的赋值，也能以shared_ptr进行初始化构造
	n1->_next = n2; 
	n2->_prev = n1;
	
    // weak_ptr可以作为shared_ptr初始化构造的值，但是无法赋值给shared_ptr
	std::shared_ptr<Node> n3(n1->_next); // 此时n3与n2指向相同

	std::cout << n3.use_count() << std::endl;
	std::cout << (n1->_next).use_count() << std::endl;
}

int main()
{
    test_cycle_ref();
    return 0;
}

⭕运行结果：

在这里插入图片描述

3. 智能指针历史

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

Ending…

超人不会飞）
关注
专栏目录
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针
05-24
C++ 中推出了强大的智能指针smart_ptr ，本文具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 2021
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
weixin_54670782的博客
12-01 3820
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
【C++进阶学习】第十三弹——C++智能指针的深入解析
2301_80220607的博客
08-13 2731
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针基础用法详解
mahuifa的博客
04-21 1268
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 805
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1688
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 142
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 647
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 794
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 660
【C++】stack和queue的使用及注意事项
C - Separated Lunch
最新发布
m0_74304371的博客
10-05 137
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值