C++ 智能指针

最新推荐文章于 2024-10-08 12:54:42 发布
最新推荐文章于 2024-10-08 12:54:42 发布
阅读量854 收藏 21
点赞数 27
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70485831/article/details/141298615
版权

1. RAII 

在很多时候，我们在使用 new 申请出一块堆上的空间后会忘记使用delete释放资源，甚至在抛异常的情况中，就算我们并没有忘记释放资源，依然会出现内存泄漏的问题，如下代码所示。

#include<iostream>
using namespace std;
double divsion(double left, double right)
{
	if (right == 0)
		throw "right==0";
	return left / right;
}

void fun(double left,double right)
{
	double* ret = new double;
	try 
	{
		*ret = divsion(left, right);
	}
	catch (const char* erremg)
	{
		cout << erremg << endl;
	}
	delete ret;
	cout << ret << endl;
}
int main()
{
	while (1)
	{
		double left, right;
		cin >> left >> right;
		fun(left, right);
	}
	
}

这里在fun函数开辟了一块double 类型和大小的空间，但是一旦divsion函数出现抛异常，只会执行catch中的语句并不会执行delete ret 的语句。

那么现在RAII的思想就可以帮助我们更好的解决问题。

RAII：用一个对象来存放和管理在堆上开辟的资源，这就是RAII的思想。（老婆怕你乱花钱，叫你把工资全给她，她帮你管）

在C++中实现RAII思想的方式就是智能指针，代码理解的方式如下所示。这里使用int_smart_point这个对象来存放在堆上申请的int类型的空间，在主函数结束时int_smart_point对象会自动的释放空间。

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

	}
	~SmPtr()
	{
		delete _ptr;
	}
private:
	T* _ptr;
};

int main()
{
	SmPtr<int> int_smart_point1 = new int;
	return 0;
}

2.智能指针

        在RAII的思想上我们还需要让这个类拥有指针的功能和行为，因此我们需要在类中重载 * 和   ->运算符。 

        在以下的代码中，重载了SmPtr这个类的* 和 ->，但是 int_smart_p1 赋值给 int_smart_p2的时候会出现问题，因为p1指向的地址拷贝给p2时是浅拷贝，p1 和 p2 指向的是同一片空间，在main函数执行完毕后，会先释放p2的空间，随后再释放p1指向的空间，在这个时候就出现了内存泄漏的问题。

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

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

int main()
{
	SmPtr<int> int_smart_point1 = new int;
#include<iostream>
using namespace std;
template<class T>
class SmPtr
{
public:
	SmPtr(T* ptr)
		:_ptr(ptr)
	{

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

int main()
{
	SmPtr<int> int_smart_point1 = new int;
	SmPtr<int> int_smart_point2 = int_smart_point1; //出错
	return 0;
}
	return 0;
}

3. C++ 98 中的智能指针

        在 98 中编译器采用了权限转移（auto_ptr）的方式来避免 一个智能指针拷贝另一个智能指针会将同一片空间析构两次的问题，它的做法是每次需要将一个指针拷贝给另一个指针时会将被拷贝指针指向空间的掌控权交给另一个指针，并且被拷贝的指针指针会失去去该空间的掌控权。

        auto_ptr这个类在C++ memory 标准库中，这样的用法因为会把一个智能指针设为空所以如果后续代码中用户对此空间进行操作的话，编译器就会报错。因此很多公司都很不建议使用这样的方式来写代码。

#include<iostream>
template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{

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

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

int main()
{
	auto_ptr<int>p1(new int);
	auto_ptr<int>p2(p1);
	return 0;
}

4. unique_ptr 

这是在C++中新增的一个类，它的作用就是直接禁止用户将一个智能指针拷贝给另一个智能指针。

非常简单粗暴，就是不给你用，人家直接就是写在库里的。

5.shared_ptr 

        这也是C++11 中新增的类，它的功能就是支持智能之间的相互拷贝，它在类中增加了一个引用计数，每当有两个对象指向了同一片空间引用计数就会加一，引用计数等于0的时候才会真正的释放指向的那片空间。

        这里引用计数器是 shared_ptr 这个类的核心，那么这个引用计数器实现的方式就是这里的关键了，这里不能使用 static 静态变量实现，因为这样的话所有同类型的 shared_ptr 对象都能访问这个static 变量，怎么可能所有的shared_ptr 对象都指向一块空间呢。

        这里引用计数器我们可以在堆上开辟一个空间专门做引用计数器，拷贝赋值时直接让堆上这个int型的变量自加就成。

智能指针的同类型构造函数

#include<iostream>
using namespace std;

	template<class T>
	class Shared_ptr
	{
	public:
		Shared_ptr(T* ptr=nullptr)
			:_ptr(ptr)
			, _count(new int(1))
		{
			*_count = 1;
			cout << "p1第一次计数=" << *_count << endl;
		}
		Shared_ptr(Shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _count(sp._count)
		{
			++(*_count);
			cout << "p1 被构造完了一次的计数" << *(sp._count) << endl;
			cout << "p2 构造了完了的计数" << *_count << endl;
		}

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

	int main()
	{
		Shared_ptr<int>p1;
		Shared_ptr<int>p2(p1);

		return 0;
	}

以下是以上代码的运行结果

 以下是shared_ptr的实现代码

#include<iostream>
using namespace std;

	template<class T>
	class Shared_ptr
	{
	public:
		Shared_ptr(T* ptr=nullptr)
			:_ptr(ptr)
			, _count(new int)
		{
			*_count = 1;
		}
		Shared_ptr(Shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _count(sp._count)
		{
			++(*_count);
		}

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

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

			return *this;
		}

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

	int main()
	{
		Shared_ptr<int>p1;
		Shared_ptr<int>p2 = p1;
		Shared_ptr<int>p3 = p2;
		return 0;
	}

6.循环引用

shared_ptr 虽然已经解决了智能指针之间相互复制的问题，但是存在循环引用的问题。如下所示

struct Node
{
    Node()
    {
        
    }
    A _a;
    shared_ptr<Node> _prev;
    shared_ptr<Node> _next;
};

int main()
{
    shared_ptr<Node> p1 (new Node);
    shared_ptr<Node> p2 (new Node);

    p1->_next = p2;
    p2->_prev = p1;

    return 0;
}

在释放此段代码的空间时会发现析构p2时，p2中的_prev需要先析构p1这个对象，但是在析构p1时，p1中的_next 需要p2被析构，这时就产生了死锁的状态。

为了解决这个问题，C++中出现了 weak_ptr 这个类。它的出现是专门解决循环引用的问题的。无法单独使用，它本身不会修改引用计数，不参与资源的管控，但是可以访问资源。将代码改成如下所示就不会报错了。

struct Node
{
    Node()
    {
        
    }
    A _a;
    weak_ptr<Node> _prev;
    weak_ptr<Node> _next;
};

int main()
{
    shared_ptr<Node> p1 (new Node);
    shared_ptr<Node> p2 (new Node);

    p1->_next = p2;
    p2->_prev = p1;

    return 0;
}

7. 定制删除器

如果申请多个多个对象时，使用的是new[]，智能指针在析构时候，默认使用的是 delete 你并不是delete[] 所以在申请多个空间后析构时会发生问题，这时候我们需要用到定制删除器来解决该问题。

如何能在结构外部按照自己的想法来控制内部代码的运行逻辑呢？其实就是用仿函数或其它可调用类型来解决：

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

void fclo(FILE* fp) {
	cout << "fclose(fp);" << endl;
	fclose(fp);
}

int main() {	  
	//传递仿函数对象
	lzh::shared_ptr<A> p1(new A[10], DeleteArray<A>());
	//传递lambda
	lzh::shared_ptr<A> p2((A*)malloc(sizeof(A)), [](A* ptr) { 
		cout << "free(ptr)" << endl;
		free(ptr); 
	});
	//传递函数指针
	lzh::shared_ptr<FILE> p3(fopen("test.cpp", "r"), fclo);
	return 0;
}

上面的这种行为就称为定制删除器，不管用什么方式申请资源，最终通过它都可以正确释放。

为了能支持定制删除器，需要对shared_ptr的代码实现进行修改，修改后如下：

template<class T>
class shared_ptr {
public:
	shared_ptr(T* ptr = nullptr) :_ptr(ptr), _pcnt(new int(1))
	{}
	//新增一个模板构造函数
	template<class D>
	//用D类型创建可调用对象
	//由于不是类模板
	//那么析构函数那里该如何拿到这个对象呢？
	//可以使用包装器，知道它的参数和返回值
	//就可以在类中定义一个包装器对象来接收它
	shared_ptr(T* ptr, D del) : _ptr(ptr), _pcnt(new int(1)), 
	_del(del)
	{}

	~shared_ptr() {
		if (--(*_pcnt) == 0) {
			//使用删除器释放
			_del(_ptr);
			delete _pcnt;
		}
	}

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

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

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

	lzh::shared_ptr<T>& operator=(const lzh::shared_ptr<T>& sp) {
		if (_ptr == sp._ptr) {
			return *this;
		}
		if (--(*_pcnt) == 0) {
			//使用删除器释放
			_del(_ptr);
			delete _pcnt;
		}
		_ptr = sp._ptr;
		_pcnt = sp._pcnt;
		++(*_pcnt);
		return *this;
	}

	int use_count() const {
		return *_pcnt;
	}

	T* get() const {
		return _ptr;
	}

private:
	T* _ptr;
	int* _pcnt;
	//包装器用来接收构造函数中的可调用对象
	//而申请单个对象时不需要传递删除器
	//所以针对最基本的情况要给它一个缺省值
	//当释放单个对象时直接使用默认的删除器即可
	function<void(T*)> _del = [](T* ptr) { delete ptr; };
};

CodingCarrot
关注
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针
Edward2022的博客
03-22 855
unique_ptr、shared_ptr、weak_ptr
C++智能指针详解
qq_61635026的博客
10-02 2023
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
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 2735
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针基础用法详解
mahuifa的博客
04-21 1275
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试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`是一种特殊的智能指针，它拥有...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1709
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
数组综合应用（下标计数）C++
最新发布
hjxxlsx的博客
10-08 745
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【C++】List
m0_46676283的博客
10-08 140
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
windows C++-创建数据流代理(三)
苏洛的博客
10-08 249
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
C++：图的最短路径问题
han2205277149的博客
10-04 1083
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 1008
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++之多态篇(超详细版)
2302_79795375的博客
10-04 881
public:cout
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值