C++智能指针

已于 2022-11-11 17:14:53 修改
阅读量623 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-11-11 00:37:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmz123_/article/details/124029863
版权

C++11前的智能指针

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

		return a / b;
}

void f1()
{
	int* p = new int;
	cout << div() << endl;
	delete p;
	cout << p << endl;
}

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

  return 0;
}

如果发生了除0错误，在f1中没有到delete p就抛异常了，这时候只能在f1中也抛异常，这样才能让p释放。

void f1()
{
	int* p = new int;
	try
	{
		cout << div() << endl;
	}
	catch(...)
	{
		delete p;
		cout << p << endl;
		throw;
	}
	delete p;
	cout << p << endl;
}

但这样处理不太好看，C++中可以用智能指针来处理。

RAII: 是一种利用对象生命周期来控制程序资源。构造函数获取资源，析构函数释放资源。
一个基本的智能指针包含两点：1、RAII。2、重载operator* 和operator-> 用起来像指针一样。

实现一个基本的智能指针：

template<class T>
class SmartPtr
{
public:
  // 1、RAII
	// 2、重载operator* 和 operator->  用起来像指针一样
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete _ptr;
		cout << _ptr << endl;
	}

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

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

private:
	T* _ptr;
};

在这里插入图片描述注意：这里的(*spp).first就是spp->first，而它原本是spp->->first，中间还有一个pair，但这样可读性太差，编译器优化成只有一个箭头就可以。

在这里插入图片描述
这里拷贝了一个智能指针，或传参时拷贝了。多个智能指针对象管理一个资源，析构时会析构多次，而这个智能指针没有写拷贝构造函数，默认构造函数会完成内置类型(T* 指针)的浅拷贝，程序崩溃。

C++98 ： 拷贝时，管理权转移（auto_ptr）
在这里插入图片描述永远只有一个对象管理资源。

赋值运算符重载也是如此，将管理权转移，把自己置空。
在这里插入图片描述但是auto_ptr的管理权转移会导致被拷贝的对象悬空，如果不小心访问了sp1就访问了空指针，是一种不好的设计。

boost库（第三方库）：scoped_ptr，shared_ptr，weak_ptr
C++11吸收了boost库的精华：unique_ptr，shared_ptr，weak_ptr

unique_ptr

设计思路：有些场景下面，智能指针仅仅用于管理资源，不需要拷贝。

防拷贝、赋值：

unique_ptr(const unique_ptr<T>& up) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

如果使用它拷贝就直接报错。

shared_ptr

在这里插入图片描述
如果count是在栈上，那么每个对象都有一个count，少一个智能指针对象就要把每个对象的count都减1才能一致，增加对象时也一样，不是只有一个count。我们要的是每个对象都使用同一个计数。

如果使用静态变量，当有多个资源对象时，每个资源对象应该有独立的计数，但静态count是所有智能指针对象共享了，也不行。
在这里插入图片描述所以我们给一个在堆上的计数变量int* count;
如果使用了拷贝构造那么智能指针对象使用的也是同一个count资源
在这里插入图片描述在这里插入图片描述
析构：
在这里插入图片描述设计思路：多个智能指针对象管理一块资源，这块资源对应一个引用计数，析构时减减计数，计数等于0时表示是最后一个管理对象，就释放资源。

赋值重载：
要注意判断是不是自己给自己赋值，如果是以下的情况，没有判断是不是自己给自己赋值，计数减为0将释放sp6，count将会被置成随机值。
在这里插入图片描述

//sp1 = sp4
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
	//if(*this != sp): 对象没有默认重载!=符号
	//if(this != &sp)：如果其中的指针_ptr指向同一块资源，但不是同一个对象，那--又++就白操作了，也不好
	if(_ptr != sp._ptr)
	{
		if(--(*pCount) == 0)
		{
			delete _pCount;
			delete _ptr;
		}

		_ptr = sp._ptr;
		_pCount = sp._pCount;
		++(*pCount);
	}
}

现代写法：sp1 = sp4，先用sp4传值拷贝构造一个sp，计数++，sp的计数换给了sp1，sp1原来的计数换给了sp，sp是个局部对象，函数结束调用析构函数释放，减少了一个计数。
在这里插入图片描述

线程安全问题

template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr)
		:_ptr(ptr)
		, _pCount(new int(1))
	{}

	// sp2(sp1)
	shared_ptr(shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		++(*_pCount);
	}
	
	// sp1 = sp4 现代写法
	shared_ptr<T>& operator=(shared_ptr<T> sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);

		return *this;
	}

	~shared_ptr()
	{
		if (--(*_pCount) == 0 && _ptr)
		{
			delete _ptr;
			delete _pCount;
			cout << _ptr << endl;
		}
	}

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

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

	int use_count()
	{
		return *_pCount;
	}

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

引用计数是智能指针的内部实现，但是资源的线程安全不是智能指针能管的。智能指针对象拷贝析构过程中引用计数的线程安全需要保障。以上代码就会引发线程安全问题。

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

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

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

void test_shared_ptr_thread_salf()
{
	my::shared_ptr<Date> p(new Date);
	cout << p.get() << endl;
	cout << p.use_count() << endl;

	const size_t n = 10000;
	thread t1(SharePtrFunc, p, n);
	thread t2(SharePtrFunc, p, n);

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

	cout << p.get() << endl;
	cout << p.use_count() << endl;

	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
}

我们可以专门抽象出来控制pCount

void add_ref()
{
	_pMtx->lock();
	++(*_pCount);
	_pMtx->unlock();
}

void release_ref()
{
	bool flag = false;
	_pMtx->lock();
	if (--(*_pCount) == 0 && _ptr)
	{
		D del;
		del(_ptr); // 使用删除器释放即可

		//delete _ptr;
		delete _pCount;
		flag = true;
		cout << "释放资源：" << _ptr << endl;
	}
	_pMtx->unlock();

	if (flag == true)
	{
		delete _pMtx;
	}
}

完整代码

template<class T, class D = DefaultDel<T>>
class shared_ptr
{
	template<class T>
	friend class weak_ptr;
public:
	explicit shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pCount(new int(1))
		, _pMtx(new mutex)
	{}

	void add_ref()
	{
		_pMtx->lock();
		++(*_pCount);
		_pMtx->unlock();
	}

	void release_ref()
	{
		bool flag = false;
		_pMtx->lock();
		if (--(*_pCount) == 0 && _ptr)
		{
			D del;
			del(_ptr); // 使用删除器释放即可

			//delete _ptr;
			delete _pCount;
			flag = true;
			cout << "释放资源：" << _ptr << endl;
		}
		_pMtx->unlock();

		if (flag == true)
		{
			delete _pMtx;
		}
	}

	// sp2(sp1)
	shared_ptr(shared_ptr<T, D>& sp)
		:_ptr(sp._ptr)
		, _pCount(sp._pCount)
		, _pMtx(sp._pMtx)
	{
		add_ref();
	}

	// sp1 = sp4
	shared_ptr<T, D>& operator=(shared_ptr<T, D> sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);

		return *this;
	}

	~shared_ptr()
	{
		release_ref();
	}

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

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

	T* get()
	{
		return _ptr;
	}

	int use_count()
	{
		return *_pCount;
	}

private:
	T* _ptr;
	int* _pCount;
	mutex* _pMtx;
};

循环引用

在这里插入图片描述
n2要销毁，它的引用计数要到0，而它被n1的_next管理，n1的_next要销毁就要让n1销毁，而n1被n2的_prev管理，n1销毁就要让n2的_prev销毁，而n2的_prev要销毁就要让n2销毁，这样两个节点都无法销毁，形成循环引用。

weak_ptr

它可以用一个shared_ptr去构造它。

在会产生循环引用的位置，把shared_ptr换成weak_ptr。

weak_ptr不是一个RAII智能指针，它不参与资源的管理，它是专门用来解决循环引用的问题的。可以把一个shared_ptr用来初始化一个weak_ptr，但是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(shared_ptr)赋值给node1->_next(weak_ptr)，不会增加node2(shared_ptr)的引用计数
 node2->_prev = node1;
 
 cout << node1.use_count() << endl;
 cout << node2.use_count() << endl;
 return 0;
}

解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。
原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

简单模拟实现：

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

	weak_ptr(shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pCount(sp._pCount)
	{}

	weak_ptr<T>& operator=(shared_ptr<T>& sp)
	{
		_ptr = sp._ptr;
		_pCount = sp._pCount;

		return *this;
	}
private:
	T* _ptr;
	int* _pCount;
};

定制删除器

前面说的指针都是new一个出来的，但如果指针是其他方式生成的呢？

std::shared_ptr<pair<int, int>> sp1(new pair<int, int>[10]);
std::shared_ptr<string> sp2(new string[10]);
std::shared_ptr<string> sp3((string*)malloc(sizeof(string)));

此时就要用到删除器进行删除，如

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

void test_deletor()
{
	std::shared_ptr<string> sp(new string[10], DeleteArray<string>());
}

定制删除器最重要的是在析构函数时调用

我们模拟实现删除器的传递位置跟std的不太一样
std的框架设计底层用一个类专门管理资源技术和释放，所以它可以在构造函数传参，把删除器类型传递给专门管理资源引用计数的这个类。
我们是一体化的，只能shared_ptr实例化给删除器，析构函数才能拿到删除器。

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

template<class T, class D = DefaultDel<T>>
class shared_ptr{...}；

void test_deletor()
{
	bit::shared_ptr<string> sp1(new string);

	bit::shared_ptr<string, DeleteArray<string>> sp2(new string[10]);

	auto ffree = [](string* ptr){free(ptr); };
	bit::shared_ptr<string, decltype(ffree)> sp4((string*)malloc(sizeof(string)));

	auto ffclose = [](FILE* ptr){fclose(ptr); };
	bit::shared_ptr<FILE, decltype(ffclose)> sp5(fopen("test.cpp", "r"));
}

总结：

  1. 不要使用auto_ptr，他是早期的设计缺陷。
  2. 不拷贝的场景建议使用unique_ptr。
  3. 如果要拷贝或者定制删除器，建议使用shared_ptr。不过要注意循环引用的问题。

智能指针的一些常见问题：

  1. 什么是RAII
  2. 了解智能指针的发展历史
  3. 模拟实现一个简洁的智能指针 – unique_ptr
  4. 什么是循环引用？如何解决？解决的原理是什么

相关知识：

内存泄漏，资源泄漏：一个内存或资源，不使用了还没释放，就会导致资源泄漏/内存泄漏。

内存泄漏危害：1、进程僵尸了，资源无法释放。2、长期运行的服务器一直泄漏。

如何避免内存泄漏：
1、事前预防：养成良好的编码规范；RAII思想或智能指针来管理资源。
2、事后查错：内存泄漏工具。Linux：valgrind

ymz123_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++新特性之四：标准库中的智能指针和引用计数
实战开发者Airex
04-30 264
总第33篇 本文主要介绍C++11/14在标准库中对智能指针和引用计数的扩充，以供大家学习和工作的过程中参考。 1.引用计数 引用计数是为了防止内存泄漏而产生的，其基本理念是：对于动态分配的对象进行引用计数，当增加一次对同一个对象的引用时，计数加1，当删除一次引用时，计数减1，当一个对象的引用计数减为0时，就自动删除指向的堆内存。 ...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++实现 带引用计数的智能指针
09-05
C++实现 带引用计数的智能指针 VS2008工程文件
c++11-智能指针和引用计数
热门推荐
icandoit2010的专栏
02-23 1万+
一、本节内容 本节内容包括： 对标准库的扩充: 智能指针和引用计数 RAII 与引用计数std::shared_ptrstd::unique_ptrstd::weak_ptr 二、RAII 与引用计数 了解 Objective-C/Swift 的程序员应该知道引用计数的概念。引用计数这种计数是为了防止内存泄露而产生的。基本想法是对于动态分配的对象，进行引用计数，每
C++ 实现智能指针（带引用计数）
xizi_ghq的博客
12-27 402
#include<bits/stdc++.h> using namespace std; //实现一个带引用计数的智能指针 /* 思路:对象有两个成员变量，一个成员变量指向资源，一个成员变量指向计数。(计数必须在堆上分配) 构造函数：让资源指针指向资源，并且创建一个和这个资源配对的int=1。 析构函数：判断int==0,决定是否释放资源 拷贝构造：int++，_p指向同一个资源 拷贝赋值运算符：检查自赋值，释放之前资源，赋值 解引用*：返回引用T ...
c++智能指针与引用计数
qq_42567607的博客
01-17 1801
先在堆上new了两个node，一个node用shared_ptr型指针parent管理，一个node用shared_ptr型指针child管理，通过重载的->可以访问管理空间中的成员，parent指针调用其中的setchild函数成员，该函数可以将node类中的shared_ptr sp_parent去管理参数传进来的指针所管理的空间，即sp_parent去管理第二次new时的空间，child指针调用其中的setparent函数成员也是如此。 代码中各个对象的关系如下图所示，parent和chi......
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`是一种特殊的智能指针，它拥有...
智能指针与引用计数详解
12-10
该demo主要展现智能指针和引用计数的实现过程，总共两个类，一个智能指针类，一个引用计数类，另外附一份执行步骤资料
C++智能指针（含内存计数）
02-16
C++智能指针（含内存计数） 完美解决内存泄漏问题。 使用智能指针就像使用指针自己一样方便
引用计数指针实现（含源码）
weixin_30561425的博客
03-11 174
引用计数指针（Reference CountedPointer）是为了解决C++必须为使用new申请的指针进行delete操作从而防止内存泄露而提出的。在C++中，new和delete必须成对出现，否则会导致内存泄露或错误。以前在写C++程序的时候，成天提心吊胆，生怕由于这个原因出现什么错误。有时候也在想，有没有一种方法，可以使编写C++程序像编写Java或者C#程序那样安心。 当然，遇到...
c++实现引用计数智能指针
qq_19408603的博客
08-19 361
主要的思路是使用一个int* 的指针进行计数，在构造函数时候设置为0，并加1（或者直接设置为1）。然后赋值和复制构造时候把int* 和数据保存的指针T* mP传到另外一个类中。在赋值的时候要注意左边的指针是否已经有数据了，有数据就要先-1，然后再进行赋值。 template class ref1 { public:     explicit ref1(T* p = NULL) : m
智能指针与引用计数：C++中的智能指针与引用计数实现
最新发布
程序员光剑
01-28 807
1.背景介绍 1. 背景介绍 智能指针和引用计数是C++中常用的内存管理技术。智能指针可以自动管理动态分配的内存，防止内存泄漏和野指针等问题。引用计数则是一种基于计数的内存管理方式，可以实现对象的自动销毁。本文将深入探讨智能指针和引用计数的实现，并提供一些最佳实践和实际应用场景。 2. 核心概念与联系 2.1 智能指针 智能指针是一种自动管理内存的指针类型，它可以自动释放内存，防止内存泄...
智能指针
Bonjour2017的博客
08-02 363
目录 基础部分 1、智能指针的引入 2、什么是智能指针 一、auto_ptr 自动指针 1、出现 2、原理 3、注意事项 二、scoped_ptr 守卫指针 1、出现 2、方法 三、shared_ptr 共享指针 1、出现 2、原理 3、循环引用 四、weak_ptr 弱指针 1、出现 2、原理 五、unique_ptr 补充： 基础部分 1、智能指...
【C++】智能指针
lyk82698的博客
11-21 666
【C++】智能指针
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值