【C++】智能指针

于 2023-11-03 22:25:07 发布
阅读量403 收藏 29
点赞数 34
分类专栏： C++修炼内功 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vhhhbb/article/details/134211842
版权

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：C++内功修炼基地
> 家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路 过的友友麻烦多多点赞关注。 欢迎你们的私信提问，感谢你们的转发！ 关注我，关注我，关注我，你们将会看到更多的优质内容！！

在这里插入图片描述

一、为什么需要智能指针

因为异常层层嵌套，执行流乱跳导致内存泄漏

int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void Func()
{
    // 1、如果p1这里new 抛异常会如何？
    // 2、如果p2这里new 抛异常会如何？
    // 3、如果div调用这里又会抛异常会如何？
    int* p1 = new int;
    int* p2 = new int;
    cout << div() << endl;
    delete p1;
    delete p2;
}
int main()
{
    try
    {
        Func();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

这里本来只想要div抛出异常，但是如果new出错也抛出异常的话，导致执行流乱跳导致资源没有释放，内存泄漏！

二、智能指针的使用

1、RAII

​ RAII是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。对象构造时获取资源,对象析构时自动释放资源。（可以利用局部对象出作用域自动调用析构函数完成对象资源的清理）

2、像指针一样

为了让智能指针像指针一样支持*、->等运算符，还需要在智能指针类中去重载这些运算符。

3、智能指针等于RAII+运算符重载

可以把new出来的资源交给智能指针的对象进行管理，对象出了作用域会调用析构函数对资源进行释放。

智能指针可以减少内存泄漏的风险。

// 使用RAII思想设计的SmartPtr类
template<class T>
    class SmartPtr {
    public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
        {}
    ~SmartPtr()
    {
        if(_ptr)
            delete _ptr;
    }

    private:
    T* _ptr;
};
int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void Func()
{
    ShardPtr<int> sp1(new int);
    ShardPtr<int> sp2(new int);
    cout << div() << endl;
}
int main()
{
    try {
        Func();
    }
    catch(const exception& e)
    {
        cout<<e.what()<<endl;
    }
    return 0;
}

三、智能指针的原理

1、auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

using namespace std;
namespace sqy
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		//管理权转移
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

		~auto_ptr()
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
		}

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

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

	void test_ptr()
	{
		auto_ptr<int> ap(new int(1));
		auto_ptr<int> ap1(ap);
	}
}

在这里插入图片描述

由于管理权转移，这个auto_ptr会导致被拷贝对象悬空

2、unique_ptr和shared_ptr

2.1、unique_ptr（唯一指针）

在这里插入图片描述

unique_ptr直接将拷贝构造和赋值给禁用了。简单粗暴。

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

2.2、shared_ptr（共享指针）

在这里插入图片描述

使用构造函数构造一个shared_ptr的对象，这个对象将会获得一个指向资源的指针和一个指向堆区的计数器。

每当拷贝构造或赋值时，让这个计数器++。每当减少一个指向该资源的对象，计数器–，直到计数器为零才释放资源及计数器。

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


		shared_ptr(const shared_ptr<T>& ap)//拷贝构造
			:_ptr(ap._ptr)
			,_pcount(ap._pcount)
		{
			++(*_pcount);
		}

		shared_ptr& operator=(shared_ptr<T>& ap)//赋值运算符重载
		{
			if (_pcount != ap._pcount)//赋值不同的对象时，引用计数才进行++
			{
				if (--(*_pcount) == 0)
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = ap._ptr;
				_pcount = ap._pcount;
				++(*_pcount);
			}
			return *this;
		}
		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

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

		T* operator->()
		{
			return &_ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};

2.3、shared_ptr是否线程安全

说到计数器，就应该想到多线程场景。一旦有多个线程同时访问计数器，对其进行+±-操作，势必会发生计数紊乱的问题。需要使用互斥锁对计数器加锁保护：

namespace sqy
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pcount(new int(1))
			,_mtx(new mutex)
		{}


		shared_ptr(const shared_ptr<T>& ap)//拷贝构造
			:_ptr(ap._ptr)
			,_pcount(ap._pcount)
			,_mtx(ap._mtx)
		{
			_mtx->lock();
			++(*_pcount);
			_mtx->unlock();

		}

		shared_ptr& operator=(shared_ptr<T>& ap)//赋值运算符重载
		{
			if (_pcount != ap._pcount)//赋值不同的对象时，引用计数才进行++
			{
				Release();
				_ptr = ap._ptr;
				_pcount = ap._pcount;
				_mtx->lock();
				++(*_pcount);
				_mtx->unlock();
			}
			return *this;
		}
		void Release()
		{
			bool flag = false;
			_mtx->lock();
			if (--(*_pcount) == 0)
			{
				flag = true;
				delete _ptr;
				delete _pcount;
			}
			_mtx->unlock();
			if (flag)//只有在其他资源释放的时候锁才要释放，使用标志进行判断释放
			{
				delete _mtx;
			}
		}
		~shared_ptr()
		{
			Release();
		}

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

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _mtx;
	};
	
struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};
int main()
{
	int n = 1000000;
	sqy::shared_ptr<Date> sp1(new Date);
	mutex mtx;
	thread t1([&]()
		{
			for (int i = 0; i < n; ++i)
			{
				sqy::shared_ptr<Date> sp2 = sp1;
				mtx.lock();
				(sp2->_day)++;
				(sp2->_month)++;
				(sp2->_year)++;
				mtx.unlock();
			}
		});
	thread t2([&]()
		{
			for (int i = 0; i < n; ++i)
			{
				sqy::shared_ptr<Date> sp3 = sp1;
				mtx.lock();
				(sp3->_day)++;
				(sp3->_month)++;
				(sp3->_year)++;
				mtx.unlock();
			}
		});
	t1.join();
	t2.join();
	std::cout << (sp1->_day) << " " << (sp1->_month) << " " << (sp1->_year) << std::endl;//cout不明确
	return 0;
}

共享指针只对计数器来说是线程安全的，但是对于共享指针指向的资源，却是线程不安全的。如上方代码，将sp1赋值给sp2和sp3，并在lambda表达式中对date中的成员变量进行++，这时资源的是线程不安全的，多线程形式使用共享指针改动资源时需要额外申请一把互斥锁进行保护。

2.4、shared_ptr循环引用问题

在这里插入图片描述

在这里插入图片描述

使用shared_ptr一旦出现循环引用的现象，将会造成内存泄漏。为了解决这一问题，可以使用weak_ptr。

3、weak_ptr指针

弱指针通常和共享指针搭配使用，解决共享指针循环引用问题。
在这里插入图片描述

​ weak_ptr支持无参的构造、支持拷贝构造、shared_ptr的拷贝构造。但是不支持使用指针进行构造，不支持RAII。

在这里插入图片描述

使用weak_ptr解决shared_ptr的循环引用问题。weak_ptr本身支持shared_ptr的拷贝与赋值，且不会增加引用计数。（weak_ptr不参与资源的管理）

四、定制删除器

析构的方式多种多样，例如数组和文件指针的释放方式不一样。这个时候就需要使用定制删除器进行对象的析构。

template <class T>
struct Delete
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
	}
};
int mian()
{
	shared_ptr<int> sp1(new int[10], Delete<int>());
	shared_ptr<string> sp2(new string[10], Delete<string>());
 
	shared_ptr<string> sp3(new string[10], [](string* ptr) {delete[] ptr; });
	shared_ptr<FILE> sp4(fopen("test.txt", "r"), [](FILE* ptr) {fclose(ptr); });
	return 0;
}

namespace sqy
{
	template<class T>
	class default_delete
	{
	public:
		void operator()(T* ptr)
		{
			delete ptr;
		}
	};
	//default_delete<T>作为默认删除器
	template<class T, class D = default_delete<T>>
	class weak_ptr
	{
	public:
	};
}

外部有传入可调用对象就使用外部传入的，否则使用默认删除器。

平凡的小苏
关注
专栏目录
智能指针
weixin_44218164的博客
04-18 908
智能指针 1.为什么引入智能指针？ 一个程序中可能因为各种情况导致内存泄漏问题，但是内存泄漏在一开始发生时并不是很容易被我们所发现，那我们先来看看内存泄漏的场景： //1.执行流跳转导致没来得及释放 void test() { int *p = (int*)malloc(100); //... //... return; //在遇到return , break, goto,continue等...
C++智能指针/C++新特性
最新发布
2403_86942375的博客
09-14 1461
多个裸指针指向同一块内存地址，即使被delete了，也有可能导致改内存空间不再被使用，从而引发内存泄漏。可以使用共享指针，当该地址的引用计数缩减为0的时候，就会重载该块地址见unique_ptr的deleterreturn;fclose(fp);可以不delete内存，而关闭文件。f为共享指针的别名，可以通过这样的操作使得b指针可以访问f指针的属性，注意b和f都必须是共享指针可以使用lamda表达式、普通函数、任意函数。
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针
05-24
C++ 中推出了强大的智能指针smart_ptr ，本文具体说说 shared_ptr 和 weak_ptr ，特别是 enable_shared_from_this 和 shared_from_this
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

平凡的小苏

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

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

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

打赏作者

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

抵扣说明：

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

余额充值