【C++学习笔记】----智能指针（auto_ptr、unique_ptr、shared_ptr、weak_ptr、定制删除器）

最新推荐文章于 2024-03-20 22:11:49 发布
最新推荐文章于 2024-03-20 22:11:49 发布
阅读量165 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41152046/article/details/107844988
版权
1.代码展示
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
namespace xff
{
	template<class T>
	class Smartptr
	{
	public:
		Smartptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			,_pmutex(new mutex)
		{
			cout << "Smartptr()" << endl;
		}

		/*~Smartptr()
		{
			if (_ptr)
			{
				delete _ptr;
				cout << "~Smartptr():" << _ptr << endl;
				_ptr = nullptr;
				_p = nullptr;
				
			}
		}*/

		//shared_ptr
		~Smartptr()
		{
			/*if (--*_pcount == 0 && _ptr)
			{
				delete _ptr;
				cout << "~Smartptr():" << _ptr << endl;
				_ptr = nullptr;
				_pcount = nullptr;
			}	*/
			release();
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* get_ptr()
		{
			return _ptr;
		}
		//auto_ptr 
		//1.管理权转移  C++98 
		/*Smartptr(Smartptr<T>& tmp)
			:_ptr(tmp._ptr)
		{
			tmp._ptr = nullptr;
		}
		Smartptr<T>& operator=(const Smartptr<T>& tmp)
		{
			if (this != &tmp)
			{
				if(_ptr)
					delete _ptr;
				_ptr = tmp._ptr;
				tmp._ptr = nullptr;
				cout << "~Smartptr():" << _ptr << endl;
			}
			return *this;
		}*/

		//unique_ptr C++11
		//防拷贝，删除默认拷贝构造和赋值
		/*Smartptr<T>& operator=(const Smartptr<T>& tmp)= delete;
		Smartptr(Smartptr<T>& tmp) =delete;*/
		

		//shared_ptr
		//指针计数
		Smartptr<T>& operator=(const Smartptr<T>& tmp)
		{
			if (this != &tmp)
			{
				/*if (--(*_pcount) == 0)//如果当前对象还管理着其他资源，要判断去除本次计数之后的数据，考虑释放问题。
				{
					delete _ptr;
					delete _pcount;
					_pcount = _ptr = nullptr;
					cout << "~Smartptr():" << _ptr << endl;
				}*/
				release();
				_ptr = tmp._ptr;
				_pcount = tmp._pcount;
				_pmutex = tmp._pmutex;

				add_ref_count();
			}
			return *this;
		}
		Smartptr(Smartptr<T>& tmp)
			:_ptr(tmp._ptr)
			, _pcount(tmp._pcount)
			,_pmutex(tmp._pmutex)
		{
			add_ref_count();
		}
		int use_count()
		{
			return *_pcount;
		}
		void add_ref_count()
		{
			_pmutex->lock();
			++(*_pcount); 
			_pmutex->unlock();
		}
		void  release()
		{
			bool flag = false;
			_pmutex->lock();

			if (--(*_pcount) == 0)
			{
				cout << "~Smartptr():" << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;

				delete _pcount;
				_pcount = nullptr;
				flag = true;
			}
			_pmutex->unlock();
			if (flag == true)
			{
				delete _pmutex;
				_pmutex = nullptr;
			}
		}
	private:
		T* _ptr;
		//static int _count;
		//用静态变量的话，同类型多个对象就不能区分了
		int* _pcount;
		mutex* _pmutex;
	};
	//template<class T>
	//int Smartptr<T>::_count = 1;
	void test_Smartptr()
	{
		int *p1 = new int(1);
		Smartptr<int> pi1(p1);
		*pi1 = 10;
		cout << *p1 << " " << *pi1 << endl;

		Smartptr<pair<int,int>> pi2(new pair<int, int>);
		pi2->first = 10;
		pi2->second = 20;
		cout << pi2->first <<" "<<pi2->second << endl;
	}

	void test_auto_ptr()
	{
		int *p1 = new int(1);
		Smartptr<int> pi1(p1);
		*pi1 = 10;
		cout << *p1 <<" "<< *pi1 << endl;
		
		//Smartptr<int> pi2 = pi1;
		//Smartptr<int> pi3(pi1);
	}

	void test_unique_ptr()
	{
		int* pi = new int(10);
		Smartptr<int> pi1(pi);
		//unique_ptr<int> pi2(pi1);
		//unique_ptr<int> pi3 = pi1;
	}

	void test_shared_ptr() 
	{
		int *p1 = new int(1);
		Smartptr<int> pi1(p1);
		*pi1 = 10;
		cout << *p1 << " " << *pi1 << endl;
		Smartptr<int> pi2 = pi1;
		Smartptr<int> pi3(pi1);
		Smartptr<int> pi4(pi1);


		Smartptr<int> pi5(new int);
		Smartptr<int> pi6(pi5);
	}

	void test_thread()
	{
		Smartptr<int> sp(new int);
		cout << sp.use_count() << endl;
		int n = 100000;
		thread t1([&]() {
			for (int i = 0; i < n; ++i)
			{ 
				Smartptr<int> sp1(sp);
			}
		});

		thread t2([&]() {
			for (int i = 0; i < n; ++i)
			{
				Smartptr<int> sp2(sp);
			}	
		});

		t1.join();
		t2.join();
		cout << sp.use_count() << endl;
	}
}


#include<memory>
void test_auto_ptr()
{
	int* pi = new int(10);
	auto_ptr<int> pi1(pi);
	auto_ptr<int> pi2(pi1);
	auto_ptr<int> pi3= pi1;
}
void test_unique_ptr()
{
	int* pi = new int(10);
	unique_ptr<int> pi1(pi);
	//unique_ptr<int> pi2(pi1);
	//unique_ptr<int> pi3 = pi1;
}
void test_shared_ptr()
{
	int *p1 = new int(1);
	shared_ptr<int> pi1(p1);
	*pi1 = 10;
	cout << *p1 << " " << *pi1 << endl;
	shared_ptr<int> pi2 = pi1;
	shared_ptr<int> pi3(pi1);
	shared_ptr<int> pi4(pi1);


	shared_ptr<int> pi5(new int);
	shared_ptr<int> pi6(pi5);
}
#include<malloc.h>
class A
{
public:

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

template<class T>//定制删除器
struct deleteArray
{
	void operator()(T* pa)
	{
		delete[] pa;
		pa = nullptr;
	}
};
void test_A()
{
	shared_ptr<A> sp1(new A);
	shared_ptr<A> sp2(new A[10],deleteArray<A>());
}

template<class T>
class Weak_ptr
{
public:
	Weak_ptr() 
	{
		cout << "Weak_ptr()" << endl;
	}
	Weak_ptr(const xff::Smartptr<T>& sp)
		:_ptr(sp.get_ptr())
	{
		
	}
	Weak_ptr<T>&operator=(xff::Smartptr<T>& sp)
	{
		_ptr = sp.get_ptr();
		return *this;
	}
	~Weak_ptr()
	{
		cout << "~Weak_ptr()" << endl;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
};
class ListNode
{
public:
	ListNode()
	{
		cout << "ListNode()" << endl;
	}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
	int _val;
	//shared_ptr<ListNode> _spnext;
	//shared_ptr<ListNode> _spprev;

	Weak_ptr<ListNode> _spnext;
	Weak_ptr<ListNode> _spprev;
};

void test_ListNode()//循环引用问题
{
	xff::Smartptr<ListNode> sp1(new ListNode);
	xff::Smartptr<ListNode> sp2(new ListNode);
	
	sp1->_spnext = sp2;
	sp2->_spprev = sp1;
	
}

int main()
{
	//xff::test_Smartptr();
	//test_auto_ptr();
	//xff::test_auto_ptr();

	//test_unique_ptr();
	//xff::test_unique_ptr();

	//test_shared_ptr();
	//xff::test_shared_ptr();

	//xff::test_thread();//线程安全问题
	//test_ListNode();//weak_ptr

	//test_A();



	system("pause");
	return 0;
}
2.auto_ptr
(1) 核心代码
//auto_ptr 
		//1.管理权转移  C++98 
		/*Smartptr(Smartptr<T>& tmp)
			:_ptr(tmp._ptr)
		{
			tmp._ptr = nullptr;
		}
		Smartptr<T>& operator=(const Smartptr<T>& tmp)
		{
			if (this != &tmp)
			{
				if(_ptr)
					delete _ptr;
				_ptr = tmp._ptr;
				tmp._ptr = nullptr;
				cout << "~Smartptr():" << _ptr << endl;
			}
			return *this;
		}*/
(2) 总结
  • 解决了赋值和拷贝构造，导致内存同一块内存释放多次的问题
  • 但是解决的不好，管理权的转移导致原有的指针访问出现问题
3.unique_ptr
(1) 核心代码
//unique_ptr C++11
		//防拷贝，删除默认拷贝构造和赋值
		/*Smartptr<T>& operator=(const Smartptr<T>& tmp)= delete;
		Smartptr(Smartptr<T>& tmp) =delete;*/
(2) 总结
  • 防止拷贝，虽然也解决了同一块内存被多次释放的问题
  • 但是有时我们也有管理同一块空间的需求
4. shared_ptr
(1) 核心代码
/shared_ptr
		//指针计数
		Smartptr<T>& operator=(const Smartptr<T>& tmp)
		{
			if (this != &tmp)
			{
				/*if (--(*_pcount) == 0)//如果当前对象还管理着其他资源，要判断去除本次计数之后的数据，考虑释放问题。
				{
					delete _ptr;
					delete _pcount;
					_pcount = _ptr = nullptr;
					cout << "~Smartptr():" << _ptr << endl;
				}*/
				release();
				_ptr = tmp._ptr;
				_pcount = tmp._pcount;
				_pmutex = tmp._pmutex;

				add_ref_count();
			}
			return *this;
		}

测试代码

void test_thread()
	{
		Smartptr<int> sp(new int);
		cout << sp.use_count() << endl;
		int n = 100000;
		thread t1([&]() {
			for (int i = 0; i < n; ++i)
			{ 
				Smartptr<int> sp1(sp);
			}
		});

		thread t2([&]() {
			for (int i = 0; i < n; ++i)
			{
				Smartptr<int> sp2(sp);
			}	
		});

		t1.join();
		t2.join();
		cout << sp.use_count() << endl;
	}
}
(2) 总结
  • 通过指针控制引用计数，控制空间的释放问题
  • 通过加锁控制，释放线程安全问题（有可能因为调度问题，导致进入释放区域的线程调度出去，别的线程也进来了，释放之后，原线程恢复上下文之后又释放 了一次）
  • shared_ptr解决了释放和线程安全的问题之后，又存在循环引用的情况，所以我们引入weak_ptr解决这个问题。
    在这里插入图片描述
5.weak_ptr
(1) 核心代码
template<class T>
class Weak_ptr
{
public:
	Weak_ptr() 
	{
		cout << "Weak_ptr()" << endl;
	}
	Weak_ptr(const xff::Smartptr<T>& sp)
		:_ptr(sp.get_ptr())
	{
		
	}
	Weak_ptr<T>&operator=(xff::Smartptr<T>& sp)
	{
		_ptr = sp.get_ptr();
		return *this;
	}
	~Weak_ptr()
	{
		cout << "~Weak_ptr()" << endl;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
};
class ListNode
{
public:
	ListNode()
	{
		cout << "ListNode()" << endl;
	}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
	int _val;
	//shared_ptr<ListNode> _spnext;
	//shared_ptr<ListNode> _spprev;

	Weak_ptr<ListNode> _spnext;
	Weak_ptr<ListNode> _spprev;
};

void test_ListNode()//循环引用问题
{
	xff::Smartptr<ListNode> sp1(new ListNode);
	xff::Smartptr<ListNode> sp2(new ListNode);
	
	sp1->_spnext = sp2;
	sp2->_spprev = sp1;
	
}
(2) 总结
  • weak_ptr通过在特殊情况下，不增加计数，就避免了循环引用的问题
6.定制删除器
(1) 核心代码
class A
{
public:

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

template<class T>//定制删除器
struct deleteArray
{
	void operator()(T* pa)
	{
		delete[] pa;
		pa = nullptr;
	}
};
void test_A()
{
	shared_ptr<A> sp1(new A);
	shared_ptr<A> sp2(new A[10],deleteArray<A>());
}
(2) 总结
  • 定制删除器通过仿函数，定制规则释放空间
NTZ5bzZKdUw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能指针auto_ptr
arhaiyun的专栏
09-21 1050
智能指针(auto_ptr) 这个名字听起来很酷是不是？其实auto_ptr 只是C++标准库提供的一个类模板，它与传统的new/delete控制内存相比有一定优势，但也有其局限。本文总结的8个问题足以涵盖auto_ptr的大部分内容。 1. auto_ptr是什么？ auto_ptr 是C++标准库提供的类模板，auto_ptr对象通过初始化指向由new创建的动态内存，它是这块内存的拥有
C++智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr
m0_49328056的博客
12-25 1094
智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr
智能指针类模板：auto_ptr、unique_ptr、shared_ptr的原理与使用
baidu_38797690的博客
06-24 1168
本文介绍了智能指针类模板的原理与使用，其中主要介绍了auto_ptr、unique_ptr、shared_ptr，它们有各自的特性，适用于不同的场景，同时也各有优点和缺陷。实际使用时要结合其特点进行选择。
C++之智能指针auto_ptr
DYDlove的博客
05-08 1572
当你在读这篇文章的时候，应该都有这样一个疑问？那就是为什么要使用智能指针。 我们先看这样一个示例： #include <iostream> #include <string> #include <exception> using std::string; void memory_demo1() { string* str = new string("今天又找了一天的bug，太累了!!!"); std::cout << *str
C++auto_ptr的用法
qq_67972375的博客
02-22 756
auto_ptr的用法
【C++】智能指针-autoptr（建议不要使用）
dai_wen的博客
07-23 1906
一、引入 1、我们先看一段代码 void FunTest() { int *p = new int[10]; FILE* fp = fopen(&quot;1.txt&quot;,&quot;rb&quot;); if(fp==NULL) { return;//因为忘记释放p，所以会造成内存的泄漏 } //Dosomething; if(p!=NULL) ...
C++学习之智能指针--auto_ptr、scoped_ptr、scoped_array、shared_ptr、shared_array、weak_ptr
enockipp的小'码'头
04-10 3215
本文主要讲解C++primer中的智能指针和句柄的概念，以及标准库中的
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
在 C++ 中，有四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，每种智能指针都有其特点和使用场景。 一、auto_ptr auto_ptr 是 C++98 中引入的智能指针，它可以自动释放动态分配的内存。但是，auto_...
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
【Boost智能指针详解：scoped_ptr、shared_ptr与weak_ptr】 智能指针是C++中用来自动管理动态分配内存的对象，它可以确保在适当的时间释放内存，以防止内存泄漏。Boost库提供了一组智能指针类型，包括scoped_ptr、...
C++11智能指针之weak_ptr详解
08-19
其中，`weak_ptr`是为了解决`shared_ptr`中可能出现的循环引用问题而引入的一种特殊类型的智能指针。本文将深入探讨`weak_ptr`的概念、用途及其使用方法。 1. 为什么需要`weak_ptr`？ `shared_ptr`是C++11中引入的...
901-基于可变参模板实现的线程池(基础知识梳理)
LINZEYU666的博客
12-06 2466
并发和并行 CPU单核 CPU多核、多CPU 并发 单核上，多个线程占用不同的CPU时间片，物理上还是串行执行的，但是由于每个线程占用的CPU时间片非常短（比如10ms），看起来就像是多个线程都在共同执行一样，这样的场景称作并发（concurrent）。 并行 在多核或者多CPU上，多个线程是在真正的同时执行，这样的场景称作并行（parallel）。 多线程的优势 多线程程序一定就好吗？不一定，要看具体的应用场景： IO密集型 （涉及I/O操作） 无论是CPU单核、CPU多核、多CPU，都是比较适合多线
webrtc中的线程(一) rtc::Thread
mo4776的博客
03-04 1061
是webrtc中最重要的线程类型。它与WebRtc库的实现深度结合。线程类型，主要是用作执行一些定时任务。这篇文章将介绍rtc::Thread及它在WebRtc中的使用。的线程模型如下： 不仅仅是只产生一个线程，它还包含一个队列**(message list)**，将它称为异步任务队列更适合。它的基本功能就是在线程中执行任务队列中的任务。它靠事件驱动，也就是说当中没有任务()时，它会阻塞在事件等待上，当有事件唤醒时后会继续在队列中去任务执行。在图中可以看到它可以处理IO事件，这里的IO事件就是网络数据的收发
C++新特性19_auto_ptr的使用及废除原因（已废除；两大缺陷：两个auto_ptr 对象不能拥有同一个内部指针所有权；两个auto_ptr对象发生赋值操作时，右者对象会丧失该所有权；接口函数）
分享学习成长历程，Winter is coming！
12-01 2301
class template: std::auto_ptr template <class X> class auto_ptr; 从官网的文档上就可以看出，这个auto_ptr指针不推荐使用(deprecated)，原因这里也有说明： auto_ptr指针在c++11标准中就被废除了，可以使用unique_ptr来替代，功能上是相同的，unique_ptr相比较auto_ptr而言，提升了安全性（没有浅拷贝），增加了特性（delete析构）和对数组的支持。 这个类模板提供了有限度的垃圾回收机
[C++11] 智能指针（auto_ptr(弃用)、unique_ptr、shared_ptr、weak_ptr）详细解读
最新发布
wangdsh的博客
03-20 1157
这里主要解释auto_ptr、unique_ptr、shared_ptr、weak_ptr这几种智能指针。接下来我们对每一个指针类型进行详细说明。在 C++ 中，auto_ptr、unique_ptr、shared_ptr 和 weak_ptr四种智能指针主要用于管理动态分配的对象的生命周期。它们在所有权管理和内存安全方面有所不同。
C++-对四个智能指针：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解
MoOtA
03-11 516
实现独占资源的方式不再是拷贝构造和拷贝赋值函数，因此，当将一个auto ptr P1赋值给另一个auto ptr P2时，编译器会报错，解决了auto ptr 赋值后指向无效数据的问题，如果实在需要像auto ptr那样赋值，可以。在C++中，有四种主要类型的智能指针：auto_ptr，unique_ptr，shared_ptr，weak_ptr。，通过计数来表明资源被几个智能指针引用和共享，当计数为0时，说明资源已经不再被任何智能指针使用，从而可以进行释放资源的操作。，多个智能指针可以指向相同的对象，
封装线程类
qq_43496435的博客
05-10 237
基于对象 Noncopyable.hh #ifndef __MY_NONCOPYABLE_H__ #define __MY_NONCOPYABLE_H__ //对线程对象、锁对象、条件变量对象等系统资源进行复制没有意义，所以禁止这些对象的复制。 //方法：让这些类继承自不可复制类 namespace my { class Noncopyable //不可复制类 { protected: Noncopyable() {} ~Noncopyable() {} Noncop.
C++智能指针——auto_ptr详解
热门推荐
yj_android_develop的博客
02-27 1万+
前言 从之前智能指针的介绍中可以了解到智能指针主要作用是管理内存，避免内存泄漏和悬垂指针。 之前介绍的不管是智能指针与引用计数详解还是智能指针与句柄详解，其核心就是通过一个类来管理被new出来的对象，具体的技术就是靠引用计数。 auto_ptr介绍 auto_ptr的实现原理其实就是RAII，在构造的时候获取资源，在析构的时候释放资源，并进行相关指针操作的重载，使用起来就像普通的指针。该智能指针已...
C++智能指针详解：unique_ptr与shared_ptr
本PPT详细介绍了C++智能指针的不同类型及其使用方法，包括`unique_ptr`、`shared_ptr`、`dynamic_pointer_cast`、`make_shared`和`make_unique`，以及在特定库如OSG和Qt中的应用。" C++智能指针是C++11引入的重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值