C++11标准下的智能指针

最新推荐文章于 2024-05-30 18:41:59 发布
最新推荐文章于 2024-05-30 18:41:59 发布
阅读量1.4k 收藏 2
点赞数 5
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36131611/article/details/117529986
版权

智能指针

为什么要提出智能指针的概念？能够解决什么问题？优点是什么？

智能指针的提出主要是解决内存泄漏的问题

那么何为内存泄漏呢？

  • 内存泄漏

内存泄漏并不是物理内存空间的丢失，而是应用程序分配某段内存空间后，由于疏忽或设计错误导致程序未能释放已经不再使用的内存空间，失去对这部分空间的控制，从而造成内存泄漏

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

  • 内存泄漏的分类

  • 堆内存泄漏（heap leak）

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

  • 系统资源泄漏

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

  • 内存泄漏解决方法

  1. 作为一位合格的程序猿或者攻城狮，工程前期就需要养成良好的代码书写规范，以及工程设计规范，凡是涉及到手动内存开辟，一定要记得及时释放，切莫置之不理。但这毕竟是一种理想状态，人为开辟内存或释放肯定会存在人为疏忽，对此，需要借助一种智能指针自动完成。
  2. 借助RALL思想完成对智能指针的设计
  3. 借助一下内存检测工具检查程序段是否存在内存泄漏

本文重点介绍通过智能指针如何解决内存泄漏

智能指针的设计主要依靠RALL思想，所谓RALL思想就是通过对象的生命周期来控制资源回收

简言之，把一份资源管理的责任托管给了对象，不再需要显示释放资源而且采用这种方式，对象所需的资源在其生命期内始终保持有效。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。

  • 常见的智能指针

  • 智能指针smart_ptr

代码如下：

#include<iostream>
using namespace std;

// 使用RAII思想设计的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;
};

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

void test()
{
	SmartPtr<int> p(new int);
	//要求必须立即初始化,以下并非立即初始化 写法错误：
	/*int* ptr = new int;
	SmartPtr<int> p(ptr);*/
	*p = 10;
	cout << *p << endl;

	SmartPtr<Date> sparray(new Date);
	sparray->_year = 2021;
	sparray->_month = 9;
	sparray->_day = 21;
	cout << (*sparray)._year << (*sparray)._month << (*sparray)._day << endl;
	return;//return后对象生命周期结束，调用析构函数自动释放空间
	cout << "test..." << endl;
}

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

  • Auto_ptr(一般不推荐使用)

实现管理权转移，当发生拷贝或赋值过程，前面的对象就被置空，将原有对象资源转移到当前对象，这虽然解决了一块内存空间多个对象调用导致崩溃的问题，但会使得原有对象失效，后续无法再调用

代码如下：

#include<iostream>
using namespace std;

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = NULL)
		: _ptr(ptr)
	{}
	~AutoPtr()
	{
		if (_ptr)
			delete _ptr;
	}
	// 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
	// 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
	AutoPtr(AutoPtr<T>& ap)
		: _ptr(ap._ptr)
	{
		ap._ptr = NULL;
	}
	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		// 检测是否为自己给自己赋值
		if (this != &ap)
		{
			// 释放当前对象中资源
			if (_ptr)
				delete _ptr;
			// 转移ap中资源到当前对象中
			_ptr = ap._ptr;
			ap._ptr = NULL;
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};

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

int main()
{
	AutoPtr<Date> ap(new Date);
	// 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
	// 通过ap对象访问资源时就会出现问题。
	AutoPtr<Date> copy(ap);
	ap->_year = 2020;
	return 0;
}

  • unique_ptr(基于auto_ptr存在问题而提出)

基本思想就是直接屏蔽拷贝和赋值

#include<iostream>
using namespace std;
template<class T>
class Unique_Ptr {
public:
	Unique_Ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	~Unique_Ptr()
	{
		if (_ptr)
			delete _ptr;
	}
	//防止拷贝delete
	Unique_Ptr(const Unique_Ptr<T>& ptr) = delete;
	Unique_Ptr<T>& operator=(const Unique_Ptr<T>& ptr) = delete;

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

​​​​​​​shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

代码如下：

#include<iostream>
using namespace std;


template<class T>

class sharedptr
{
public:
	sharedptr(T* ptr)
		:_ptr(ptr)
		,_pRefCount(new int(1))
	{}

	sharedptr(const sharedptr<T>& s)
		:_ptr(s._ptr)
		, _pRefCount(s._pRefCount)
	{
		(*_pRefCount)++;
	}

	sharedptr<T>& operator=(const sharedptr<T>& sp)
	{
		if (this != &sp)
		{
			// 释放管理的旧资源
			if (--(*_pRefCount) == 0)   //注意：此处计数器指针与下面的计数器指针并非指向同一个  一个指向原有资源计数，另一个指向新资源计数
			{                           //赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1
				delete _ptr;
				delete _pRefCount;
			}
			// 共享管理新对象的资源，并增加引用计数
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			
			(*_pRefCount)++;
		}
		return *this;
	}

	~sharedptr()
	{
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
		}
	}

	int UseCount() { return *_pRefCount; }

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

private:
	int* _pRefCount; // 引用计数,
	T* _ptr; // 指向管理资源的指针
};

int main()
{
	sharedptr<int> sp1(new int(10));
	sharedptr<int> sp2(sp1);
	*sp2 = 20;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	sharedptr<int> sp3(new int(10));
	sp2 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	sp1 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	return 0;
}

注意：

  1. 计数器定义为指针，目的是保证不同对象析构后，计数器值要同步更新
  2. 在赋值运算符重写过程中   此处计数器指针与下面的计数器指针并非指向同一个  一个指向原有资源计数，另一个指向新资源计数。赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1

  •  shared_ptr循环引用​​​​​​​

​​​​​​​代码如下：

#include<iostream>
using namespace std;


template<class T>

class sharedptr
{
public:
	sharedptr(T* ptr)
		:_ptr(ptr)
		,_pRefCount(new int(1))
	{}

	sharedptr(const sharedptr<T>& s)
		:_ptr(s._ptr)
		, _pRefCount(s._pRefCount)
	{
		(*_pRefCount)++;
	}

	sharedptr<T>& operator=(const sharedptr<T>& sp)
	{
		if (this != &sp)
		{
			// 释放管理的旧资源
			if (--(*_pRefCount) == 0)   //注意：此处计数器指针与下面的计数器指针并非指向同一个  一个指向原有资源计数，另一个指向新资源计数
			{                           //赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1
				delete _ptr;
				delete _pRefCount;
			}
			// 共享管理新对象的资源，并增加引用计数
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			
			(*_pRefCount)++;
		}
		return *this;
	}

	~sharedptr()
	{
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
		}
	}

	int UseCount() { return *_pRefCount; }

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

private:
	int* _pRefCount; // 引用计数,
	T* _ptr; // 指向管理资源的指针
};

struct ListNode
{
	int _data;
	sharedptr<ListNode> _prev;
	sharedptr<ListNode> _next;
	ListNode()
		:_prev(nullptr)
		,_next(nullptr)
		,_data(10)
	{}
	~ListNode() { cout << "~ListNode()" << endl; }
};

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

node1->_next = node2;和node2->_prev = node1;时  导致引用计数增加为2

出现问题：

node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。也就是说_next析构了，node2就释放了。 _prev析构了，node1就释放了。
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁都不会释放资源

  • 采用weak_ptr解决上述问题 

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

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

HT . WANG
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++11 weak_ptr智能指针详解
二进制君
04-10 4783
weak_ptr这个指针天生一副“小弟”的模样，也是在C++11的时候引入的标准库，它的出现完全是为了弥补它老大shared_ptr天生有缺陷的问题，其实相比于上一代的智能指针auto_ptr来说，新进老大shared_ptr可以说近乎完美，但是通过引用计数实现的它，虽然解决了指针独占的问题，但也引来了引用成环的问题，这种问题靠它自己是没办法解决的，所以在C++11的时候将shared_ptr和weak_ptr一起引入了标准库，用来解决循环引用的问题。weak_ptr本身也是一个模板类，但是不能直接用它来定
【C++11】Smart Pointer 智能指针 shared_ptr
qq_35516517的博客
01-15 134
在C++里，我们用new delete 两个操作符管理动态内存，new出的对象内存在堆上。 一旦我们忘记释放动态内存会导致内存泄漏。 shared_ptr ：允许多个指针指向同一个对象 shared_ptr<int> p1; // 定义一个指向int的智能指针 shared_ptr<list<int>>p1; // 定义一个指向lits<int>的智能指针 shared_ptr<int> p2(new int(42)); //定义...
C++11——智能指针
weixin_44479862的博客
02-15 382
C++11——智能指针
【C++】智能指针
最新发布
m0_74246469的博客
05-30 952
智能指针的全方位讲解
C++11特性 - Smart Pointers 智能指针
yofer张耀琦的专栏
09-02 1556
已经有成千上万的文章讨论这个问题了，所以我只想说：现在能使用的，带引用计数，并且能自动释放内存的智能指针包括以下几种：         unique_ptr: 如果内存资源的所有权不需要共享，就应当使用这个（它没有拷贝构造函数），但是它可以转让给另一个unique_ptr（存在move构造函数）。         shared_ptr: 如果内存资源需要共享，那么使用这个（所以叫这个名字）
C++标准库与OSG库智能指针对比记录
Alezan的博客
03-19 279
转载 mark一下总结帖： https://www.cnblogs.com/wuyepeng/p/9741241.html https://www.cnblogs.com/greatverve/p/smart-ptr.html 个人记录 std::weak_ptr<>和osg::observer_ptr<> 感觉C++的weak_ptr没有osg中osg::obser...
智能指针的发展史
跑够一万公里就结婚
08-04 439
1 .智能指针的发展史 智能指针的发展要从RAII说起，RAII要求，资源的有效期与持有资源的对象的生命期严格绑定，即由对象的构造函数完成资源的分配(获取)，同时由析构函数完成资源的释放。在这种要求下，只要对象能正确地析构，就不会出现资源泄露问题。 （1）C++98提出auto _Ptr,auto_Ptr的设计是让两个指针指向同一块空间，但是这样会存在释放不当，出现程序崩溃的问题。 （2）在
C++11 智能指针
惜暮
12-15 825
本文主要讲解C++11中的智能指针 主要内容： 原始指针使用有什么缺点（主要是资源释放、证明周期、挂起引用） C++98里面的auto_ptr有什么缺点(所有权转移问题、不能指向数组、不能与容器组合使用) C++11提出的更加智能指针： shared_ptr、weak_ptr、unique_ptr优势 ...
2小时精通C++智能指针
06-18
本课程讲解C++11标准库中的智能指针。对于C/C++程序员来说，指针是天堂，也是地狱。指针用得好程序运行效率倍增，用得不好问题层出不穷。智能指针可以解决普通指针存在的悬垂指针、野指针、资源泄露等问题本教程的...
C++11，智能指针详解，以及面试常见问题
goodgood_UP的博客
01-14 1055
四种智能指针详解，含面试常见问题
C++11智能指针之weak_ptr详解
08-19
在C++11标准中，智能指针是用于自动管理动态分配对象生命周期的重要工具，极大地减少了内存泄漏的风险。其中，`weak_ptr`是为了解决`shared_ptr`中可能出现的循环引用问题而引入的一种特殊类型的智能指针。本文将...
智能指针
a15929748502的博客
08-20 225
智能指针：智能指针是RAII思想的一种应用，智能的管理类对象资源的申请和释放。 目前有以下几种： C 98中提出 auto_ptr（一个较为早期的版本（日常是不用的）解决拷贝构造（多次释放）的方法是管理权转移（以前的对象不再管理，把旧对象的管理空间的权限交给旧对象拷贝出的新对象，把旧对象管理空间的指针值交给新对象之后，把旧对象管理空间的指针赋为空），有效的避免了会出现多次释放,后来又有人提出...
C++中各种智能指针的实现及弊端（一）
wolfGuiDao的博客
01-01 1210
C++中各种智能指针的实现及弊端（一） 一、为什么需要智能指针？ 首先看一段代码： #include <vector> void _MergeSort(int* a, int left, int right, int* tmp) { if (left >= right) return; int mid = left + ((right - left) >> 1); /...
RAll思想
qq_43711837的博客
07-13 285
RAll思想
RALL 与 智能指针
BlackMonkeyHH的博客
10-19 1177
什么是RALL思想及其应用，智能指针的理解与实现。
智能指针基础知识【C++】【RAII思想 || unique_ptr || shared_ptr&weak_ptr || 循环引用问题】
菜菜成长为后端开发大佬
03-08 1226
内存泄漏非常常见，解决方案分为两种：1、事前预防型，如。
C++ RAII机制浅谈
树欲静静风不止止的博客
11-17 2781
RALL机制使得C++程序员能够优雅的释放内存。
c++标准库智能指针
09-07
智能指针是C++标准库中的一个重要组成部分。它帮助C++程序员解决了内存开辟和释放的问题，使得程序员不再像C语言一样担心内存泄漏的问题。使用智能指针需要包含头文件#include 。 在使用智能指针时，应避免混用普通...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HT . WANG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值