C++ unique_ptr介绍及仿写

最新推荐文章于 2024-06-21 15:39:12 发布
最新推荐文章于 2024-06-21 15:39:12 发布
阅读量714 收藏 2
点赞数 3
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jqivin/article/details/117163165
版权
本文详细介绍了C++智能指针unique_ptr的使用，包括其特性、成员方法，并展示了如何仿写unique_ptr。重点强调了unique_ptr的非拷贝性、移动语义以及对动态数组的支持。同时，文中给出了仿写unique_ptr的代码实现，包括特化版本，用于管理动态数组。
摘要由CSDN通过智能技术生成

文章目录

一、unique_ptr的使用

（1）构造函数不能进行隐式转换。
（2）unique_ptr可以指向动态数组。因为unique_ptr有unique_ptr<T[]>重载版本，销毁动态对象时调用delete[]。
（3）unique_ptr无拷贝语义，但提供了移动语义，所以可作为函数返回值。与容器在一块使用时要注意。
（4）谨慎使用智能指针的get与release方法
当使用get方法返回裸指针时，智能指针并没有释放指向对象的所有权，所以我们必须小心使用裸指针以避免程序崩溃。但通过unique_ptr.release()方法返回的裸指针，需要我们自己delete删除对象，因为调用release方法后，该unique_ptr不再拥有对象的所有权。

class Object
{
private:
	int value;
public:
	Object(int val = 0) :value(val) { cout << "construct Object" << endl; }
	~Object() { cout << "destruct Object" << endl; }
	int Value() { return value; }
	const int  Value() const { return value; }

};
int main()
{
	unique_ptr<Object> pO(new Object(10));
	unique_ptr<Object> pO2(new Object(20));
	unique_ptr<int> pi(new int(1));
	cout << pO->Value() << endl;
	cout << *pi << endl;
	//pO = pO2;								//编译不通过，不能拷贝构造或者赋值
	pO = std::move(pO2);					//移动之后pO2就析构掉了
	//cout << pO2->Value() << endl;			 //错误：如果不注释掉就执行失败，因为pO2已经没有对象资源的所有权了
	cout << pO->Value() << endl;
	int* p = pi.release();
	// cout << *pi << endl;					//错误：release之后也会释放资源的所有权
	cout << "*p=" << *p << endl; delete p;

	cout << endl;
	unique_ptr<int[]> ps1(new int[10]{ 1,2,3,4,5,6,7,8,9,10 });
	//cout << *ps1 << endl;    特化版本不重载* ->
	for (int i = 0; i < 10; i++)
	{
		cout << ps1[i] << " ";
	}
	cout << endl;
	Object* Obj = new Object[]{ 10,20,30 };
	delete[]Obj;
	unique_ptr<Object[] > pobj(new Object[]{ 10,20,30 });

	cout << pobj[0].Value() << endl;;

	return 0;
}

结果
在这里插入图片描述

二、unique_ptr类的成员方法

1.非特化版本

在这里插入图片描述

2.特化版本

缺少运算符*，->的重载，多了[]的重载；
在这里插入图片描述

get（）函数:只是得到unique_ptr指向的资源
release（）:函数是释放unique_ptr指向的资源，返回值是指向的资源
swap（）:交换两个unique_ptr指向的资源，参数是unique_ptr类型
reset（）:重置unique_ptr指向的资源，先释放原来的资源，然后将指针指向新的资源。参数是指针类型，而不是unique_ptr类型。

int main()
{
	unique_ptr<int> up(new int(10));
	int* p = up.get();        //get()只是得到unique_ptr指向的资源
	cout << "*p=" << *p << endl;    //10
	cout << "*up=" << *up << endl;  //10

	unique_ptr<int> up2(new int(20));
	up2.swap(up);            //交换资源
	cout << *up <<" " << *up2 << endl;   //20  10

	up2.reset(new int(30));   
	cout << *up2 << endl;   //30

	int* p2 = up.release();    //release释放unique_ptr对资源的所有权
	cout << "*p2=" << *p2 << endl;     //20
	cout << "*up=" << *up << endl;     //出错，已经不拥有资源了
	return 0;
}

三、仿写

#include<iostream>
using namespace std;
#if 1
namespace jqw
{
//默认的删除器
template <class _Ty>
struct default_delete
{public:
	void operator()(_Ty* ptr)const
	{
		delete ptr;
	}
};
//数组的删除器
template <class _Ty>
struct default_delete<_Ty[]>
{
	void operator()(_Ty* ptr)const 
	{
		delete []ptr;
	}
};

template <class _Ty, typename _Dp  = default_delete<_Ty>>
class unique_ptr
{
private:
	_Ty* _Ptr;
public:
	typedef _Ty* pointer;
	typedef _Ty element_type;
	typedef _Dp delete_type;
	delete_type get_deleter() { return delete_type(); } //删除器获取函数
	//构造函数  不可以隐式转换
	explicit unique_ptr(_Ty* ptr = nullptr):_Ptr(ptr){}
	//析构函数
	~unique_ptr()
	{
		if (_Ptr)
		{
			//delete _Ptr;
			get_deleter()(_Ptr);

		}
	}
	//拷贝构造和赋值函数delete掉
	unique_ptr(unique_ptr<_Ty>& p) = delete;
	unique_ptr<_Ty>& operator=(const unique_ptr<_Ty>& p) = delete;
	//移动构造函数和移动赋值
	unique_ptr(unique_ptr<_Ty>&& p)
	{
		if (_Ptr != p._Ptr)
		{
			//delete _Ptr;		//XXXXXXXXXXX
			get_deleter()(_Ptr);
			_Ptr = p._Ptr;
			p._Ptr = nullptr;
		}
	}
	unique_ptr<_Ty>& operator=(unique_ptr<_Ty>&& p)
	{
		if (this != &p)
		{
			//delete _Ptr;
			get_deleter()(_Ptr);
			_Ptr = p._Ptr;
			p._Ptr = nullptr;
		}
		return *this;
	}
	
	//获取资源
	pointer get() const
	{
		return _Ptr;
	}
	//判断智能指针是否拥有资源  ?????、返回类型
	explicit  operator bool() const
	{
		return _Ptr != nullptr;
	}
	//重载运算符* ->
	_Ty* operator->() const
	{
		return get();
	}
	const _Ty& operator*() const
	{
		return *_Ptr;
	}
	//释放函数
	pointer release()
	{
		_Ty* tmp = this->_Ptr;
		this->_Ptr = nullptr;
		return tmp;
	}
	//重置资源
	void reset(_Ty* p = nullptr)
	{
		//delete _Ptr;			//XXXXX
		get_deleter()(_Ptr);
		_Ptr = p;
	}
	//交换
	void swap(unique_ptr& _u)
	{
		std::swap(_Ptr, _u._Ptr);
	}
};
//
template <class _Ty, typename _Dp>
class unique_ptr<_Ty[],_Dp>   //特化版本，用户可以自己写 _Dp 删除器
{
private:
	_Ty* _Ptr;
public:
	typedef _Ty* pointer;
	typedef _Ty element_type;
	typedef _Dp delete_type;
	delete_type get_deleter() { return delete_type(); } //删除器获取函数
	//构造函数
	explicit unique_ptr(_Ty* ptr = nullptr) :_Ptr(ptr) {}
	//析构函数
	~unique_ptr()
	{
		if (_Ptr)
		{
			//delete _Ptr;
			get_deleter()(_Ptr);

		}
	}
	//拷贝构造和赋值函数delete掉
	unique_ptr(unique_ptr<_Ty>& p) = delete;
	unique_ptr<_Ty>& operator=(const unique_ptr<_Ty>& p) = delete;
	//移动构造函数和移动赋值
	unique_ptr(unique_ptr<_Ty>&& p)
	{
		if (_Ptr != p._Ptr)
		{
			//delete _Ptr;		//XXXXXXXXXXX
			get_deleter()(_Ptr);
			_Ptr = p._Ptr;
			p._Ptr = nullptr;
		}
	}
	unique_ptr<_Ty>& operator=(unique_ptr<_Ty>&& p)
	{
		if (this != &p)
		{
			delete _Ptr;
			_Ptr = p._Ptr;
			p._Ptr = nullptr;
		}
		return *this;
	}

	//获取资源
	pointer get() const
	{
		return _Ptr;
	}
	//判断智能指针是否拥有资源  ?????、返回类型
	explicit  operator bool() const
	{
		return _Ptr != nullptr;
	}
	//重载运算符* ->
	_Ty* operator->() const
	{
		return get();
	}
	const _Ty& operator*() const
	{
		return *_Ptr;
	}
	//释放函数
	pointer release()
	{
		_Ty* tmp = this->_Ptr;
		this->_Ptr = nullptr;
		return tmp;
	}
	//重置资源
	void reset(_Ty* p = nullptr)
	{
		//delete _Ptr;			//XXXXX
		get_deleter()(_Ptr);
		_Ptr = p;
	}
	//交换
	void swap(unique_ptr& _u)
	{
		std::swap(_Ptr, _u._Ptr);
	}
	_Ty& operator[](int index)
	{
		return _Ptr[index];
	}
};
}
class Object
{
private:
	int value;
public:
	Object(int val = 0) :value(val) { cout << "construct Object" << endl; }
	~Object() { cout << "destruct Object" << endl; }
	int Value() { return value; }
	const int  Value() const { return value; }
	
};
int main()
{
	jqw::unique_ptr<Object> pO(new Object(10));
	jqw::unique_ptr<Object> pO2(new Object(20));
	jqw::unique_ptr<int> pi(new int(1));
	cout << pO->Value() << endl;
	cout << *pi << endl;
	//pO = pO2;								//编译不通过，不能拷贝构造或者赋值
	pO = std::move(pO2);					//移动之后pO2就析构掉了
	//cout << pO2->Value() << endl;			 //错误：如果不注释掉就执行失败，因为pO2已经没有对象资源的所有权了
	cout << pO->Value() << endl;
	int* p = pi.release();
	// cout << *pi << endl;					//错误：release之后也会释放资源的所有权
	cout << "*p=" << *p << endl; delete p;

	cout << endl;
	jqw::unique_ptr<int[]> ps1(new int[10]{ 1,2,3,4,5,6,7,8,9,10 });
	cout << *ps1 << endl;
	for (int i = 0; i < 10; i++)
	{
		cout << ps1[i] << " ";
	}
	cout << endl;
	Object* Obj = new Object[]{ 10,20,30 };
	delete []Obj;
	jqw::unique_ptr<Object[] > pobj(new Object[]{ 10,20,30 });

	cout << pobj[0].Value() << endl;;
	
	return 0;
}
#endif

结果：和系统提供的一致，（仿写特化版本没有删除* ->的重载）
在这里插入图片描述

Jqivin
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++之独占智能指针unique_ptr的实现
m0_58495729的博客
10-21 1015
unique_ptr要求只能有一个智能指针指向该堆区空间
C++ 之实现自己的 unique_ptr
weixin_30699741的博客
06-13 552
1. 几个基本成员函数的作用： u.reset() 释放u指向的对象 u.reset(q) 如果提供了内置指针q，就令u指向这个对象 u.reset(nullptr) 将 u 置为空 u.release() u 放弃对指针的控制权，返回指针，并将 u 置为空 2. 一些规则： 某个时刻只能有一个unique_ptr 指向一个...
default delete函数
最新发布
2301_82343802的博客
06-21 313
使用=default可以显示要求编译器自动生成默认或复制构造函数。delete不限于在无参和复制构造函数上使用。当然default只能合成简单的不含参数的。除析构函数外都可以用delete删去。其他使用含参数的构造函数则不可以。delete可以删去复制构造函数。
C++ 智能指针 unique_ptr 详解与示例
梁启东的博客
10-15 476
unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现，独享被管理对象指针所有权的智能指针。unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。 unique_ptr具有->和*运算符重载符，因此它可以像普通指针一样使用。 查看下面的示例： #include <iostream> #i...
C++简单实现unique_ptr
Cdreamfly的博客
03-07 2029
唯一指针 管理指针的存储，提供有限的垃圾回收工具，与内置指针相比几乎没有开销（取决于所使用的删除程序）。 这些对象具有获取指针所有权的能力：一旦它们获得所有权，它们就会通过在某个时候负责删除指向的对象来管理指向的对象。 unique_ptr对象在它们本身被销毁时，或者一旦它们的值通过赋值操作或显式调用unique_ptr::reset而改变，就会自动删除它们所管理的对象（使用删除器）。 unique_ptr对象唯一地拥有其指针：任何其他工具都不应负责删除该对象，因此任何其他托管指针都不应指向其托管对象，因为
c++ unique_ptr共享指针release函数
纪录成长
02-09 1754
c++中unique_ptr与share_ptr、weak_ptr的一个经典问题就是release，release函数表示只释放指针，但是内存并不释放，即release后，内存仍被占用，且其他占用该内存的指针仍然可以正常使用。上述代码中up释放后，main函数中p仍然不受影响。
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智能指针中的 unique_ptr实例详解
08-19
《C++11智能指针中的unique_ptr实例详解》 C++11引入了智能指针，其中的unique_ptr是一种非常重要的智能指针类型。它以其“独特性”和“唯一性”为特点，提供了对对象所有权的严格管理，确保了资源在不再需要时能够...
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++ 中使用lambda代替 unique_ptr 的Deleter的方法
08-30
在C++编程中，`std::unique_ptr`是一种智能指针，它负责管理动态分配的对象，并在不再需要对象时自动释放内存。`unique_ptr`的一个关键特性是它的删除器（Deleter），这是一个用于销毁所指向对象的函数或函数对象。...
玩具版C++ 智能指针 unique_ptr的实现
you558的博客
07-19 125
#include<algorithm> #include<iostream> #include<vector> template<class T> void defaultfunc(T* p) { if (p) delete(p); } template<class T,class D=decltype(defaultfunc<T>)*> class myunique_ptr { public: explicit myun
C++ unique_ptr
niaxiapia的博客
06-29 3102
智能指针unique_ptr 常用函数 get 用途：获取被管理的裸指针。 release 用途：释放其关联的原始指针的所有权，并返回原始指针，但是并未delete原始指针。 res
C++ unique_ptr的模拟实现
weixin_43850474的博客
05-24 455
一、unique_ptr的模拟实现 在之前的博客中，我说过auto_ptr的缺陷，所以为了避免auto_ptr的缺陷，所以unique_ptr用了一个简单粗暴的办法：防拷贝、防赋值。既然auto_ptr在拷贝和赋值的时候，会出现一些问题，那么在unique_ptr中就不让他进行拷贝和赋值。 那么如何禁止它拷贝和赋值呢？ 我们都知道，如果我们没有定义拷贝构造和赋值运算符重载函数时，编译器会为其生成默认的拷贝构造和赋值运算符重载。所以我们可以用下面两种办法来实现禁止拷贝和赋值。 方法一： 在C++98中 将拷贝
C++ Primer笔记——allocator、unique_ptr和release、智能指针与动态数组、阻止拷贝
weixin_61857742的博客
01-01 1894
声明但不定义一个函数是合法的，但是有一个例外，就是派生类对基类虚函数的覆盖，如果只有声明将在多态调用时发生链接错误，无法找到绑定的虚函数的定义。与new不同的是，它一般是提前分配了一大块未初始化的空间，使用时再根据所需空间大小进行初始化，其实就是将一块空间资源让使用者自行维护。，因此使用动态数组时只需要在对象类型后提供一对方括号，表明指针指向的是一个数组。值得注意的是，此时的空间并不能够直接使用，因为没有进行初始化操作。参数p是指针，指向释放资源起始位置，n是要释放的该类型资源的数量。
c++11 - unique_ptr的一个实现
weixin_30609331的博客
08-25 108
在单位写代码没法用c++11,为了方便写代码，今天趁着空闲时间写了个unique_ptr的简单实现 //default deleter for unique_ptr template<typename T> struct DefaultDeleter { void operator()(T *p) ...
独占指针unique_ptr 的 release（） 函数 分析
zhangzhangkeji的博客
06-05 289
其中最后的静态转换没太明白，但大致显示了，该函数返回了裸指针的结论。
C++ 智能指针unique_ptr原理与自定义实现
newchenxf的专栏
04-29 5511
分析 智能指针最常用的，就是shared_ptr和unique_ptr。第一个，我在另一个文章已介绍（https://blog.csdn.net/newchenxf/article/details/116019535）。本文来单独说以下unique_ptr。 先说其特点： 独享它指向的对象。也就是说，同时只有一个unique_ptr指向同一个对象，当这个unique_ptr被销毁时，指向的对象也随即被销毁。 这也是它和shared_ptr不一样的地方。它不需要做引用计数，也不可以被第二个人引用。只有它自己。
智能指针之unique_ptr简单实现-实现篇
初见时的微笑
07-25 2916
1 序 1.1 智能指针 为了避免手动在堆中分配出的内存没有释放造成内存泄露的问题，C++11提供了智能指针。 智能指针将指针封装成一个栈对象。栈对象在生命周期结束自动销毁时会调用析构函数。智能指针基本上也是在析构函数中做文章，实现的堆上内存管理。 C++11推荐使用的智能指针有unique_ptr、shared_ptr和weak_ptr三种。 1.2 内容简介 本文为std::unique_ptr的实现篇，介绍实现一个UniquePtr类，实现与std::unique_ptr类似的功能。代码实现参考了st
C++ unique_ptr
12-15
C++11中的unique_ptr是一种智能指针，它提供了一种独占式拥有其所指向对象的所有权的语义，即同一时间内只能有一个unique_ptr指向一个对象。当unique_ptr被销毁时，它所指向的对象也会被销毁。unique_ptr的使用可以避免内存泄漏和悬空指针等问题。 以下是unique_ptr的基本使用方法： 1. 创建unique_ptr对象 ```c++ std::unique_ptr<int> p(new int(10)); // 创建一个指向int类型对象的unique_ptr ``` 2. 获取unique_ptr指向的对象 ```c++ int a = *p; // 获取unique_ptr指向的对象的值 ``` 3. 释放unique_ptr指向的对象 ```c++ p.reset(); // 释放unique_ptr指向的对象 ``` 4. 将unique_ptr转移给其他unique_ptr ```c++ std::unique_ptr<int> p1 = std::move(p); // 将p指向的对象的所有权转移给p1 ``` 需要注意的是，由于unique_ptr的独占性质，不能将一个unique_ptr赋值给另一个unique_ptr或者将一个unique_ptr作为参数传递给一个函数，除非使用std::move进行转移。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值