智能指针简述

最新推荐文章于 2024-08-18 21:07:18 发布
最新推荐文章于 2024-08-18 21:07:18 发布
阅读量137 收藏
点赞数 1
分类专栏： C++八股文 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013183558/article/details/128393979
版权

为什么要智能指针

通过普通指针，我们能轻松访问到数据的地址。但是，我们往往会忘记在合适的地方释放它。那么有没有一种方法，来辅助我们释放指针呢？答案是有的，就是接下来要介绍的智能指针。

栈空间和堆空间

我们先引入两个概念，栈空间和堆空间。简单来说，栈空间由系统分配和释放，堆空间由程序猿申请和释放。我们可以利用栈的特性来帮助释放指针。

class HelpPtr
{
public:
	HelpPtr() {}
	~HelpPtr() {}
};
int main()
{
	HelpPtr ptr;
	return 0;
}

先看上面的代码，在main函数中，我们申明了一个局部变量。根据栈空间的特性，在函数返回后，ptr是不是就自动释放了呢，释放时会调用析构函数。发散一下，如果ptr中保存了一个指针，在析构函数中将指针delete，我们没有主动调用delete，HelpPtr帮我们做了。

class A
{	
public:
	A() {}
};

class HelpPtr
{
public:
	HelpPtr(A* pA) 
	{
		m_pA = pA;
	}
	~HelpPtr() 
	{
		delete m_pA;
	}
private:
	A* m_pA = nullptr;
};
int main()
{
	A* pA = new A();
	HelpPtr ptr(pA);	
	return 0;
}

再看上面的代码，将第一部分代码稍作变形，将指针A保存到HelpPtr中，即使没有在main函数中调用delete，妈妈再也不担心内存泄漏了。
以下内容只会介绍C++11之后的智能指针，C++11之前的std::auto_ptr已经被摒弃，另外例如非官方大神实现的scoped_ptr智能指针，这里都不做介绍。

独享智能指针（unique_ptr）

std::unique_ptr是一个独享型的智能指针，它不允许其他的智能指针共享其内部的指针。
独享智能指针帮助我们管理释放指针，它不允许其他智能指针共享其内部的指针。为实现这种效果，我们应该把独享类的拷贝构造函数和赋值函数都隐藏起来。当然，为了这个独享类能将其他类包装成智能指针，必须使用模板类的方式来实现。

//unique.h
#pragma once

template<typename  T>
class UniquePtr
{
public:
	UniquePtr(T* p = nullptr) :m_p(p){}
	~UniquePtr()
	{
		if (m_p) delete m_p;
	}

	T* operator->()
	{
		return this->m_p;
	}

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

	T* get()
	{
		return this->m_p;
	}

protected:
	UniquePtr(const UniquePtr<T>& ptr) {}
	UniquePtr<T>& operator=(const UniquePtr<T>& ptr) {}

private:
	T* m_p = nullptr;
};

#pragma once

#include <iostream>
#include "unique.h"
using namespace std;

class A
{
public:
	A() {}
};

int main()
{
	A* pA = new A();
	UniquePtr<A> APtr(pA);

	UniquePtr<A> A2Ptr = APtr; //报错
	return 0;
}

上面的代码编译时，会报如下错误。因为我们实现的是独享指针，那么就不能将智能指针赋值给其他的智能指针，这其实就是scope_ptr的实现。
在这里插入图片描述
C++11后形成了std::unique_ptr智能指针，基本和scope_ptr相同，不过它们之间也有一些细微差别。就是unique_ptr可以对右值进行转移，对右值转移这是啥意思呢？说明白了就是提供了一种特殊方法可以将unique_ptr赋值给另一个unique_ptr，被转移后的unique_ptr也就不能再处理之前管理的指针了。

//unique.h
#pragma once

template<typename  T>
class UniquePtr
{
public:
	UniquePtr(T* p = nullptr) :m_p(p){}
	~UniquePtr()
	{
		if (m_p) delete m_p;
	}

	T* operator->()
	{
		return this->m_p;
	}

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

	T* get()
	{
		return this->m_p;
	}

	UniquePtr(UniquePtr<T>&& ptr) noexcept 
		: m_p(ptr.m_p) 
	{
		ptr.m_p = nullptr;
	}

	UniquePtr& operator=(UniquePtr<T>&& ptr) noexcept
	{
		if (this != &ptr)
		{
			m_p = ptr.m_p;
			ptr.m_p = nullptr;
		}
		return *this;
	}

protected:
	UniquePtr(const UniquePtr<T>& ptr) {}
	UniquePtr<T>& operator=(const UniquePtr<T>& ptr) {}

private:
	T* m_p = nullptr;
};

#pragma once

#include <iostream>
#include "unique.h"
using namespace std;

class A
{
public:
	A() {}
};

int main()
{
	A* pA = new A();
	UniquePtr<A> APtr(pA);

	//UniquePtr<A> A2Ptr = APtr; //报错
	UniquePtr<A> A2Ptr = std::move(APtr);
	return 0;
}

上面main函数中的第四行调用的是拷贝构造函数，由于该函数不是public属性，所以调用该行时会失败。而第五行会调用移动构造函数，因为我们已经实现了移动构造函数，所以该行可以编译成功。在运行时，当APtr移动给A2Ptr 后，APtr也就失去了对原指针的控制权，这在代码中也有体现就是将 ptr.m_p设置为nullptr了。

上面就是C++11标准中的unique_ptr的实现，这样一分析下来也是蛮简单的对吧。

共享智能指针（shared_ptr）

虽然unique_ptr已经很好用了，但有时候我们还是需要多个智能指针管理同一块堆内存空间。有个不错的解决方案—引用计数法。其基本原理是当有多个智能指针指对同一块堆空间进行管理时，每增加一个智能指针引用计数就增1，每减少一个智能指针引用计数就减少。当引用计数减为0时，就将管理的堆空间释放掉。
看文字可能比较抽象，直接上代码：

//shared.h
#pragma once

template<typename  T>
class SharedPtr
{
public:
	SharedPtr(T* p = nullptr) :m_p(p), m_pRefCnt(new int(1)) {}

	SharedPtr(const SharedPtr<T>& ptr)
	{
		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(*m_pRefCnt);
	}

	SharedPtr<T>& operator=(const SharedPtr<T>& ptr) 
	{
		if (this != &ptr)
		{
			releaseRef(); //接受另外一个智能指针时，应该将自身的先释放掉

			m_p = ptr.m_p;
			m_pRefCnt = ptr.m_pRefCnt;
			++(*m_pRefCnt);
		}

		return *this;
	}

	~SharedPtr()
	{
		releaseRef();
	}

	T* operator->()
	{
		return this->m_p;
	}

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

	T* get()
	{
		return this->m_p;
	}

	int refCnt()
	{
		return *m_pRefCnt;
	}

private:
	void releaseRef()
	{
		if (--(*m_pRefCnt) == 0) 
		{
			delete m_p;
			delete m_pRefCnt;
		}
	}

private:
	T* m_p = nullptr;
	int* m_pRefCnt = nullptr;
};

#pragma once

#include <iostream>
#include "shared.h"
using namespace std;

class A
{
public:
	A() {}
};

int main()
{
	A* pA = new A();
	SharedPtr<A> APtr(pA);

	SharedPtr<A> A2Ptr = APtr; //不会报错
	return 0;
}

从结果中我们可以看到创建APtr时引用计数为 1，将APtr赋值给A2Ptr时引用计算都为2。当main程序结束后首先释放A2Ptr ，其引用计数都减1。再释放APtr，引用计数减为0，当引用计数为0时，释放堆空间。这样的智能指针还是非常棒的，我们再也不怕内存泄漏了！

可惜的是，我们高兴的有点早，当指针循环指向的时候，还是会出现内存泄漏的情况。例如：

struct Node
{
    SharedPtr<Node> _prev;
    SharedPtr<Node> _next;

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

SharedPtr<Node> ptrCur(new(Node));
SharedPtr<Node> ptrNext(new(Node));
ptrCur->_next = ptrNext;
ptrNext->_prev = ptrCur;

这里大家可以自行分析一下释放顺序，有助于大家进一步理解引用计数，这里就不分析内存泄漏的原因了。

弱智能指针（weak_ptr）

为了解决这个bug，C++11提供了一个辅助指针类型weak_ptr。实际上weak_ptr不能单独称为一个智能指针，它必须与shared_ptr一起使用，起到辅助share_ptr的作用。我们来看看它是如何解决上述问题的吧。
在之前的shared.h上修改，直接上代码：

#pragma once

struct Counter
{
	int sRef = 0; //存放SharedPtr引用计数
	int wRef = 0; //存放WeakPtr的引用计数
};

template<typename T>
class WeakPtr;

template<typename  T>
class SharedPtr
{
public:
	SharedPtr(T* p = nullptr) :m_p(p), m_pRefCnt(new Counter())
	{
		if (p != nullptr)
		{
			m_pRefCnt->sRef = 1;
		}
	}

	SharedPtr(const SharedPtr<T>& ptr)
	{
		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(m_pRefCnt->sRef);
	}
	
	SharedPtr(const WeakPtr<T>& ptr)
	{
		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(m_pRefCnt->sRef);
	}

	SharedPtr<T>& operator=(const SharedPtr<T>& ptr) 
	{
		if (this != &ptr)
		{
			releaseRef(); //接受另外一个智能指针时，应该将自身的先释放掉

			m_p = ptr.m_p;
			m_pRefCnt = ptr.m_pRefCnt;
			++(m_pRefCnt->sRef);
		}

		return *this;
	}

	~SharedPtr()
	{
		releaseRef();
	}

	T* operator->()
	{
		return this->m_p;
	}

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

	T* get()
	{
		return this->m_p;
	}

	int refCnt()
	{
		return m_pRefCnt->sRef;
	}

private:
	void releaseRef()
	{
		if (--(m_pRefCnt->sRef) == 0) 
		{
			delete m_p;
			if(m_pRefCnt->wRef == 0)
			{
				delete m_pRefCnt;
				m_pRefCnt = nullptr;
			}
		}
	}

private:
	T* m_p = nullptr;
	Counter* m_pRefCnt = nullptr;

	friend class WeakPtr<T>;
};

template<typename T>
class WeakPtr
{
public:
	WeakPtr(){}

	WeakPtr(const WeakPtr<T>& ptr)
	{
		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(m_pRefCnt->wRef);
	}

	WeakPtr(const SharedPtr<T>& ptr)
	{
		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(m_pRefCnt->wRef);
	}

	WeakPtr<T>& operator=(const WeakPtr<T>& ptr)
	{
		if (this != &ptr)
		{
			releaseRef(); //接受另外一个智能指针时，应该将自身的先释放掉

			m_p = ptr.m_p;
			m_pRefCnt = ptr.m_pRefCnt;
			++(m_pRefCnt->wRef);
		}

		return *this;
	}

	WeakPtr& operator=(const SharedPtr<T>& ptr)
	{
		releaseRef();

		m_p = ptr.m_p;
		m_pRefCnt = ptr.m_pRefCnt;
		++(m_pRefCnt->wRef);

		return *this;
	}

	~WeakPtr()
	{
		releaseRef();
	}

	SharedPtr<T> lock()
	{
		return SharedPtr<T>(*this);
	}

	bool expried()
	{
		if (m_pRefCnt && m_pRefCnt->sRef > 0)
			return false;

		return true;
	}

private:
	void releaseRef()
	{
		if (m_pRefCnt)
		{
			--(m_pRefCnt->sRef);
			
			if (m_pRefCnt->wRef < 1 && m_pRefCnt->sRef < 1)
			{
				m_pRefCnt = nullptr;
			}
		}
	}

private:
	T* m_p = nullptr;
	Counter* m_pRefCnt = nullptr;
};

#pragma once

#include <iostream>
#include "shared.h"
using namespace std;

struct Node
{
	WeakPtr<Node> _prev;
	WeakPtr<Node> _next;

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

int main()
{
	SharedPtr<Node> cur(new(Node));
	SharedPtr<Node> next(new(Node));
	cur->_next = next;
	next->_prev = cur;

	return 0;
}

以上就是WeakPtr的实现以及SharedPtr的改造，从中我们可以看到，SharedPtr与我们之前的SharedPtr区别并不是很大，主要做了以下三点修改：
1、以前只有一个计数器，然在变成了两个，一个是SharedPtr本身的计数，另一个是WeakPtr的计数；
2、是增加了一个参数为WeakPtr引用的拷贝构造函数;
3、m_ptr和m_pRefCnt的释放都是在SharedPtr中完成的，WeakPtr不做具体的释放工作。

WeakPtr是新增加的弱指针，它是配合SharedPtr使用的，自己并不能单独使用。WeakPtr也包含m_ptr和m_pRefCnt两个成员，但它更多是是引用，对它们没有创建和释放权。另外在WeakPtr中会对Counter对象的wRef操作，也就是说多个WeakPtr指向同一个堆空间时，它仅操作Counter中的wRef。
因此，对于我们之前的SharedPtr形成环后导致的内存泄漏可以通过WeakPtr对其进行改造，这样内存泄漏的问题就迎刃而解了。

同样的，上面main函数的释放过程，大家自己分析。

MissingMe__
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能指针详解
weixin_59371851的博客
10-01 4895
C++11中引入了智能指针的特性，本文将详细介绍智能指针的使用。1、为什么需要智能指针？{delete p1;delete p2;}在这段代码中，如果在div中抛异常，很显然会造成内存泄漏。为了避免内存泄漏，我们希望有一种指针可以做到自动管理内存释放。
智能车比赛初赛试题（笔试）
02-26
### 智能车比赛初赛试题（笔试）知识点解析 #### 基础题解析 **1. 数组访问** 题目中给出了一个初始化数组 `int a[] = {1,2,3,10,9,8,7,6,5};` 并询问 `a[a[2]+2]` 的值。 - **解析:** 首先明确数组索引从0开始，...
智能指针（一介绍）
程序员的规则
01-13 306
智能指针
智能指针详细解析(智能指针的使用，原理解析)
qq_61988957的博客
12-01 4603
智能指针的使用跟普通指针类似，可以使用运算符“ * " 和 ” -> "去获得指向的对象，因此，我们就需要在类中重载" * " 和" -> "函数。当程序结束时，此时ptr1和ptr2指针被销毁时，对象ptr1和ptr2会自动调用析构函数去释放所指向的资源，这是智能指针特点。由于我的类中没有定义拷贝构造函数和赋值重载函数，那么我们只能调用类中原生的拷贝构造函数和赋值重载函数。那么就会程序就会出现崩溃的问题，如下:ptr2和ptr1指向的同一块空间。
智能指针之共享指针shared_ptr、弱指针weak_ptr、独占式指针unique_ptr
qq_43148810的博客
10-07 2708
@著作权归作者所有：来自CSDN博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.csdn.net/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! class MyClass { public: MyClass(int m = 0) :M(m){ std::cout << "构造 " << M << std::endl; } MyClass(MyClass& myC) :M(myC.M){
【C++】智能指针简述(六):智能指针总结及补充
weixin_30877181的博客
04-03 75
　　本文我们主要来总结一下前文介绍过的智能指针相关原理及实现,顺便补充一下前文未提到的shared_ptr删除器部分的内容. 总结: 　　1.智能指针,通过RAII机制,构造对象时完成资源的初始化,析构对象时,对资源进行清理和汕尾. 　　2.auto_ptr,防止拷贝/赋值对象后,析构时多次delete对象导致程序崩溃,因此它通过“转移所有权”,完成赋值/拷贝,保证只有一个对象维护、释放指针...
C++-详解智能指针
weixin_52159554的博客
12-01 2812
RAII）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：不需要显式地释放资源。采用这种方式，对象所需的资源在其生命期内始终保持有效。
【C++】智能指针简述(一):智能指针的引入
weixin_30314813的博客
03-31 78
　　智能指针是C++中一种利用RAII机制(后面解释),通过对象来管理指针的一种方式. 　　在C++中,动态开辟的内存需要我们自己去维护,在出函数作用域或程序异常退出之前,我们必须手动释放掉它,否则的话就会引起内存泄漏. 　　例如:我们用指针变量来创建对象时,需要手动来删除它 string * pstr = new string("hello world!"); .... delete ...
C++ 智能指针
爱吃柚子的好奶罐
04-16 328
目录 1. 产生的原因 2. 智能指针简介 3. auto_ptr 4. unique_ptr 5. shared_ptr 6. weak_ptr 参考链接： auto_ptr 参考 shared_ptr参考 1. 产生的原因 内存泄漏 当我们当从堆中申请了内存后，如果不释放空间，就发生内存泄漏。内存泄漏的情景主要有一下几种： * new和delete没有匹配。 * 没有正确清楚嵌套对象...
【C++】智能指针简述(四):shared_ptr
weixin_33890499的博客
03-18 59
2019独角兽企业重金招聘Python工程师标准>>> ...
简述C语言及发展应用.pdf
09-19
C语言支持多种数据类型，包括基本类型（整型、实型和字符型）、构造类型（数组、结构体、共用体和枚举型）、指针类型和空类型。 运算符是C语言操作数据的基本工具，大致可以分为三类：单目运算符（如自增运算符“++...
C++复试和面试题汇总
03-22
C++增加了 const 常量、引用、强制类型转换、智能指针、Lambda 匿名 函数、右值引用等新特性，功能语法更为灵活复杂； • C++可复用性高，引入了模板概念，在此基础上实现了 STL 标准模板库， 大大方便了开发...
C++面试题，针对资深开发工程师面试题目含详细解答
03-20
C++5年以上资深工程师面试题目以及详细解答。 1 简述C、C++程序编译的内存分配情况 2 谈谈你对拷贝构造函数...19 智能指针是线程安全的吗？哪些地方需要考虑线程安全？ 20 虚函数表是在什么时候确定的？那虚表指针呢？
SQL数据库
03-11
在VC++中使用ADO时，会频繁使用到三个智能指针：`_ConnectionPtr`、`_CommandPtr`和`_RecordsetPtr`。这些智能指针用于管理与数据库的连接、执行SQL命令以及处理结果集。 - `_ConnectionPtr`用于表示数据库连接，是...
C++匿名函数lamba简介
yao_tao11的博客
08-18 516
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1030
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式
最新发布
2403_83044722的博客
08-18 338
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 335
C++ | Leetcode C++题解之第337题打家劫舍III
什么是智能指针？简述智能指针实现原理
03-14
智能指针是一种用于管理动态分配的内存资源的指针对象。它可以自动地在适当的时候释放内存，避免内存泄漏和悬空指针的问题。 智能指针的实现原理主要有两种：不带引用计数的智能指针和带引用计数的智能指针。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值