智能指针派生类—unique_ptr(STL源码)

最新推荐文章于 2024-07-01 10:17:11 发布
最新推荐文章于 2024-07-01 10:17:11 发布
阅读量811 收藏
点赞数
分类专栏： 智能指针 STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38850997/article/details/104088087
版权 

// unique_ptr指针(唯一指向资源的指针，每当赋值、构造时，转让右侧指针数据到左侧，右侧为空，即同一时间只有一个指针指向数据)
// 其中，千万别在定义一个unique_ptr指针时出现下述情况已知unique_ptr<int> q(new int(1));q也可以是shared_ptr<int>类型
// unique_ptr<int> p(q.get());这是合法且编译通过(但是就出现了两智能指针指向同一内存的现象)，所以当p离开其作用域且q依旧在其作用域范围内时，p的释放导致q为悬空指针，q释放时就会导致重复释放而引起的错误。
// 例如:
std::unique_ptr<int> q(new int(111111));
//std::shared_ptr<int> qq = std::make_shared<int>(2222);
{
	//std::unique_ptr<int> p(q.get());		// 隐含错误:p和q同时指向同一内存，局部变量p离开作用于析构释放内存，导致q成为悬空指针
	//std::unique_ptr<int> pp(qq.get());	// 隐含错误:道理同上
	std::unique_ptr<int> p(q.release());	// .release().q主动放弃内存资源占有权同时置空并返回原指针(ok)，shared_ptr没有释放内存且返回原内存指针的函数
}
// TEMPLATE CLASS unique_ptr SCALAR
template<class _Ty,
	class _Dx>	// = default_delete<_Ty>
	class unique_ptr
		: private _Unique_ptr_base<_Ty, _Dx,
			is_empty<_Dx>::value	// 非空 或是 默认删除器 则为true(特化版)
				|| is_same<default_delete<_Ty>, _Dx>::value>
	{	// non-copyable pointer to an object
public:
	typedef unique_ptr<_Ty, _Dx> _Myt;	// 自身类型
	typedef _Unique_ptr_base<_Ty, _Dx,
		is_empty<_Dx>::value
			|| is_same<default_delete<_Ty>, _Dx>::value> _Mybase;// 基类类型
	typedef typename _Mybase::pointer pointer;
	typedef _Ty element_type;
	typedef _Dx deleter_type;

	using _Mybase::get_deleter;// 访问申明

	unique_ptr() _NOEXCEPT
		: _Mybase(pointer())
		{	// default construct
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}

	unique_ptr(nullptr_t) _NOEXCEPT
		: _Mybase(pointer())
		{	// null pointer construct
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}
	// 不允许指针之间的赋值，但可以赋值为0
	_Myt& operator=(nullptr_t) _NOEXCEPT
		{	// assign a null pointer
		reset();// 释放资源
		return (*this);
		}

	explicit unique_ptr(pointer _Ptr) _NOEXCEPT
		: _Mybase(_Ptr)
		{	// construct with pointer
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}

	unique_ptr(pointer _Ptr,
		typename _If<is_reference<_Dx>::value, _Dx,
			const typename remove_reference<_Dx>::type&>::type _Dt) _NOEXCEPT
		: _Mybase(_Ptr, _Dt)
		{	// construct with pointer and (maybe const) deleter&
		}

	unique_ptr(pointer _Ptr,
		typename remove_reference<_Dx>::type&& _Dt) _NOEXCEPT
		: _Mybase(_Ptr, _STD move(_Dt))
		{	// construct by moving deleter
		static_assert(!is_reference<_Dx>::value,
			"unique_ptr constructed with reference to rvalue deleter");
		}
	// 移动copy
	unique_ptr(unique_ptr&& _Right) _NOEXCEPT
		: _Mybase(_Right.release(),// 释放右侧无名对象
			_STD forward<_Dx>(_Right.get_deleter()))
		{	// construct by moving _Right
		}

	template<class _Ty2,
		class _Dx2,
		class = typename enable_if<!is_array<_Ty2>::value
			&& is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer,
				pointer>::value
			&& ((is_reference<_Dx>::value && is_same<_Dx, _Dx2>::value)
				|| (!is_reference<_Dx>::value
					&& is_convertible<_Dx2, _Dx>::value)),
			void>::type>
		unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right) _NOEXCEPT
			: _Mybase(_Right.release(),
				_STD forward<_Dx2>(_Right.get_deleter()))
		{	// construct by moving _Right
		}

	template<class _Ty2,
		class = typename enable_if<is_convertible<_Ty2 *, _Ty *>::value
			&& is_same<_Dx, default_delete<_Ty> >::value,
			void>::type>
		unique_ptr(auto_ptr<_Ty2>&& _Right) _NOEXCEPT
			: _Mybase(_Right.release())
		{	// construct by moving _Right
		}

	template<class _Ty2,
		class _Dx2>
		typename enable_if<!is_array<_Ty2>::value
			&& is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer,
				pointer>::value,
			_Myt&>::type
		operator=(unique_ptr<_Ty2, _Dx2>&& _Right) _NOEXCEPT
		{	// assign by moving _Right
		reset(_Right.release());
		this->get_deleter() = _STD forward<_Dx2>(_Right.get_deleter());
		return (*this);
		}
	// 移动赋值
	_Myt& operator=(_Myt&& _Right) _NOEXCEPT
		{	// assign by moving _Right
		if (this != &_Right)
			{	// different, do the move
			reset(_Right.release());
			this->get_deleter() = _STD forward<_Dx>(_Right.get_deleter());
			}
		return (*this);
		}

	void swap(_Myt& _Right) _NOEXCEPT
		{	// swap elements
		_Swap_adl(this->_Myptr, _Right._Myptr);
		_Swap_adl(this->get_deleter(),
			_Right.get_deleter());
		}

	~unique_ptr() _NOEXCEPT
		{	// destroy the object
		if (this->_Myptr != pointer())
			this->get_deleter()(this->_Myptr);// 析构，调用删除器函数对象释放资源
		}

	typename add_reference<_Ty>::type operator*() const
		{	// return reference to object
		return (*this->_Myptr);
		}

	pointer operator->() const _NOEXCEPT
		{	// return pointer to class object
		return (_STD pointer_traits<pointer>::pointer_to(**this));
		}

	pointer get() const _NOEXCEPT
		{	// return pointer to object
		return (this->_Myptr);
		}

	explicit operator bool() const _NOEXCEPT
		{	// test for non-null pointer
		return (this->_Myptr != pointer());
		}
	// 放弃对资源的控制，返回资源指针
	pointer release() _NOEXCEPT
		{	// yield ownership of pointer
		pointer _Ans = this->_Myptr;
		this->_Myptr = pointer();
		return (_Ans);
		}
	// 建立新的指针数据，释放old指针数据
	void reset(pointer _Ptr = pointer()) _NOEXCEPT
		{	// establish new pointer
		pointer _Old = this->_Myptr;
		this->_Myptr = _Ptr;
		if (_Old != pointer())
			this->get_deleter()(_Old);
		}
	// 定义为delete，不允许copy构造和赋值构造
	unique_ptr(const _Myt&) = delete;
	_Myt& operator=(const _Myt&) = delete;
	};







// TEMPLATE CLASS unique_ptr ARRAY
// 指针数组模板类
template<class _Ty,
	class _Dx>
	class unique_ptr<_Ty[], _Dx>
		: private _Unique_ptr_base<_Ty, _Dx,
			is_empty<_Dx>::value
				|| is_same<default_delete<_Ty[]>, _Dx>::value>
	{	// non-copyable pointer to an array object
public:
	typedef unique_ptr<_Ty[], _Dx> _Myt;
	typedef _Unique_ptr_base<_Ty, _Dx,
		is_empty<_Dx>::value
			|| is_same<default_delete<_Ty[]>, _Dx>::value> _Mybase;
	typedef typename _Mybase::pointer pointer;
	typedef _Ty element_type;
	typedef _Dx deleter_type;

	using _Mybase::get_deleter;

	unique_ptr() _NOEXCEPT
		: _Mybase(pointer())
		{	// default construct
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}

	explicit unique_ptr(pointer _Ptr) _NOEXCEPT
		: _Mybase(_Ptr)
		{	// construct with pointer
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}

	unique_ptr(pointer _Ptr,
		typename _If<is_reference<_Dx>::value, _Dx,
			const typename remove_reference<_Dx>::type&>::type _Dt) _NOEXCEPT
		: _Mybase(_Ptr, _Dt)
		{	// construct with pointer and (maybe const) deleter&
		}

	unique_ptr(pointer _Ptr,
		typename remove_reference<_Dx>::type&& _Dt) _NOEXCEPT
		: _Mybase(_Ptr, _STD move(_Dt))
		{	// construct by moving deleter
		static_assert(!is_reference<_Dx>::value,
			"unique_ptr constructed with reference to rvalue deleter");
		}

	unique_ptr(unique_ptr&& _Right) _NOEXCEPT
		: _Mybase(_Right.release(),
			_STD forward<_Dx>(_Right.get_deleter()))
		{	// construct by moving _Right
		}

	_Myt& operator=(_Myt&& _Right) _NOEXCEPT
		{	// assign by moving _Right
		if (this != &_Right)
			{	// different, do the swap
			reset(_Right.release());
			this->get_deleter() = _STD move(_Right.get_deleter());
			}
		return (*this);
		}

	unique_ptr(nullptr_t) _NOEXCEPT
		: _Mybase(pointer())
		{	// null pointer construct
		static_assert(!is_pointer<_Dx>::value,
			"unique_ptr constructed with null deleter pointer");
		}

	_Myt& operator=(nullptr_t) _NOEXCEPT
		{	// assign a null pointer
		reset();
		return (*this);
		}

	void reset(nullptr_t) _NOEXCEPT
		{	// establish new null pointer
		reset();
		}

	void swap(_Myt& _Right) _NOEXCEPT
		{	// swap elements
		_Swap_adl(this->_Myptr, _Right._Myptr);
		_Swap_adl(this->get_deleter(), _Right.get_deleter());
		}

	~unique_ptr() _NOEXCEPT
		{	// destroy the object
		_Delete();
		}

	// 重载[]
	typename add_reference<_Ty>::type operator[](size_t _Idx) const
		{	// return reference to object
		return (this->_Myptr[_Idx]);
		}

	pointer get() const _NOEXCEPT
		{	// return pointer to object
		return (this->_Myptr);
		}

	explicit operator bool() const _NOEXCEPT
		{	// test for non-null pointer
		return (this->_Myptr != pointer());
		}

	pointer release() _NOEXCEPT
		{	// yield ownership of pointer
		pointer _Ans = this->_Myptr;
		this->_Myptr = pointer();
		return (_Ans);
		}

	void reset(pointer _Ptr = pointer()) _NOEXCEPT
		{	// establish new pointer
		_Delete();
		this->_Myptr = _Ptr;
		}

	template<class _Ptr2>
		explicit unique_ptr(_Ptr2) = delete;

	template<class _Ptr2,
		class _Dx2>
		unique_ptr(_Ptr2, _Dx2) = delete;

	unique_ptr(const _Myt&) = delete;

	_Myt& operator=(const _Myt&) = delete;

	template<class _Ptr2>
		void reset(_Ptr2) = delete;

private:
	void _Delete()
		{	// delete the pointer
		if (this->_Myptr != pointer())
			this->get_deleter()(this->_Myptr);
		}
	};

 

ztq小天
关注
专栏目录
Essential_C++随书源码
12-10
6. **内存管理**：动态内存分配（new和delete操作），智能指针（如unique_ptr、shared_ptr和weak_ptr）的使用。 7. **STL（Standard Template Library）**：容器（如vector、list、set、map等），迭代器，算法（如...
C++11 智能指针实现分析
谁动了我的tori的博客
05-20 979
首先声明本文研究的代码为vs2012中的源码，这个编译器还未支持变长参数模板，所以一些地方仍然使用着非常变态的宏元代码。在vs2015版本中，这些智能指针的实现都有了一些细微的变化。可以说随着编译器的更新，一些源码的实现也会跟着发生变化本文分析主题有三个，分别是C++11中的三种类型的智能指针。其中还包含辅助他们工作的一些列代码。废话不多说，直接进入正题 unique_ptrunique_ptr是...
【智能指针1】unique_ptr源码剖析
m0_37957950的博客
06-15 1738
C++智能指针的源码剖析。
C++ STL unique_ptr智能指针源码剖析
最新发布
新法的博客
07-01 1314
unique_ptr的删除器默认使用delete直接释放内存unique_ptr与shared_ptr不同,unique_ptr有删除器,shared_ptr没有unique_ptr底层使用tuple存储相关信息,由于是独占式,所以没有引用计数uple`存储相关信息,由于是独占式,所以没有引用计数使用new创建一个对象,而不是STL空间配置器,原因是unique_ptr的默认删除器使用delete。
GCC STL源码学习（六） —— unique_ptr
文天_Teddy的专栏
03-15 197
GCC STL源码学习（六） —— unique_ptr
unique-ptr源码解析
JAN6055的博客
10-05 1542
std::unique_ptr源码解析
C/C++学习记录：智能指针 std::unique_ptr 源码分析
这里是河边
11-02 1793
抽空扣一点感兴趣的标准库源码，这里总结一下 std::unique_ptr 相关的分析 本文中 gcc version: 8.4.1 20200928 (Red Hat 8.4.1-1) (GCC) libstdc++:libstdc++-8.4.1-1.el8.x86_64 其中c++库安装路径为 /usr/include/c++/8 目录一、前言二、源码分析1. 从 class unique_ptr 入手2. 储存类 class __uniq_ptr_impl3. 默认删除器 struct defa.
C++编程思想(第2版)_第1卷_标准C++引导 源码
02-10
10. **智能指针（Smart Pointer）**：C++11引入的智能指针如unique_ptr、shared_ptr和weak_ptr，自动管理动态分配的对象，解决了原始指针可能导致的内存管理问题。 通过阅读《C++编程思想》第一卷，结合源码实践，...
易学C++经典源码C++经典源码
10-28
9. **高级主题**：可能会有线程编程、内存管理、智能指针（shared_ptr、unique_ptr等）的示例。 10. **算法与数据结构**：包括排序（快速排序、归并排序等）、搜索（二分查找、哈希查找等）、图算法（Dijkstra、...
C++谭浩强（课件源码正文图片）
05-15
9. **内存管理**：C++允许直接操作内存，包括动态内存分配（new和delete）和智能指针（如unique_ptr、shared_ptr和weak_ptr），理解内存管理是避免内存泄漏和提高程序稳定性的关键。 10. **C++11及后续标准**：C++...
Professional C++ Source Code（C++高级编程 源码）
12-16
智能指针如`std::unique_ptr`、`std::shared_ptr`和`std::weak_ptr`是C++11引入的重要特性，用于自动管理对象的生命周期。源码将展示如何使用它们避免内存泄漏和悬空指针问题。 5. **RAII（Resource Acquisition ...
unique_ptr源码
02-28
该文档是C++ auto_ptr源码，感兴趣的可以自行下载学习，方便大家学习参考。
【C++智能指针】unique_ptr的源码详解以及应用实例
b_r_ight的博客
04-21 1360
C++11智能指针的原理和使用
【C++】unique_ptr独占型智能指针详解
Yngz_Miao的博客
04-24 2万+
指针是C/C++区别于其他语言的最强大的语法特性，借助指针，C/C++可以直接操纵内存内容。但是，指针的引入也带来了一些使用上的困难，这要求程序员自己必须手动地对分配申请的内存区进行管理。 本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q2/20200424。 unique_ptr基本用法 un...
C++11中unique_ptr的使用
热门推荐
网络资源是无限的
08-14 4万+
在C++中，动态内存的管理是通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，可以选择对对象进行初始化；delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。 动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时会忘记释放内存，在这种情况下会产生内存泄露；有时在尚有指针引用内存的情况下就释放了它，在这种情况下就会产生引用...
unique_ptr功能、源码解析、使用范例
游戏猫的博客
07-18 758
一、概述 unique_ptr用于管理对象，实现对象的自动释放，它不能被拷贝或赋值，保证了指针只被它管理，提供了接口转移拥有权。 二、使用示例 #pragma once #include <memory> #include <string> #include <iostream> using namespace std; class PtrClass { private: string s; public: PtrClass(string s) { this-&
C++ 智能指针 unique_ptr 详解与示例
梁启东的博客
10-15 479
unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现，独享被管理对象指针所有权的智能指针。unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。 unique_ptr具有->和*运算符重载符，因此它可以像普通指针一样使用。 查看下面的示例： #include <iostream> #i...
《Effective Modern C++》学习笔记 - Item 18: 使用 std::unique_ptr 管理独占性资源（附MSVC源码解析）
アルタイル
12-27 948
std::unique_ptr 占用空间与裸指针相同，大多数操作（包括解引用）的方法也相同。它表现的是 独占性拥有（exclusive ownership） 的语义，这意味着它不能被拷贝，是 move-only 类型；当其自身被销毁时，总会销毁其拥有的资源。而对象的销毁在作用域结束（即右大括号出现）时自动通过调用析构函数进行，此时 std::unique_ptr 默认对内部的裸指针进行 delete，因此你无需像裸指针一样操心什么时候要手动销毁。 （注：笔者尽己所能对MSVC的 std::unique_p.
智能指针之unique_ptr
moter的专栏
11-12 1万+
unique_ptr用于独占它所指向的对象。某个时刻只能有一个unique_ptr指向一个给定的对象，也就是这个对象不会被多个unique_ptr同时共享，它只提供了移动语义，即它所管理的资源对象只能在unique_ptr之间进行移动，不能拷贝。资源对象的生命周期被唯一的一个unique_ptr托管着，一旦unique_ptr被销毁或者变成empty对象，或者拥有了另一个资源对象，它先前拥有的对象同时一并销毁，显然一旦对象离开unique_ptr的管理范围就会销毁，保证了内存不会泄露。 下面看一下它的用法。
C++智能指针详解：unique_ptr, weak_ptr, shared_ptr, auto_ptr
"本文主要介绍了C++中的四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，包括它们的使用方式、工作机制以及可能存在的缺陷。智能指针是为了解决C++中动态内存管理和指针操作可能导致的问题，如内存泄漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值