C++11智能指针unique_ptr剖析

已于 2022-09-06 16:16:12 修改
阅读量451 收藏
点赞数
分类专栏： C++ 文章标签： java 算法 c++
于 2022-09-05 21:31:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/126699499
版权

文章目录

unique_ptr介绍

unique_ptr实现了独享被管理对象指针的概念，这意味着它可以确保一个对象和其对应的资源同一时间只被一个unique_ptr对象拥有。一旦拥有者被销毁或者变成empty，或者开始管理另一个对象，先前拥有的对象就会被销毁，相应资源被回收

unique_ptr特点：

  • delete： 左值引用拷贝构造和赋值
  • 提供 ：右值引用拷贝构造或者赋值运算符
  • 右值引用拷贝构造或者赋值时，会release前一个对象的资源，保证只有一个unique_ptr指向资源
template <class T>
class My_unique_ptr {
public:
	using elem_type = T;
	using elem_ptr = T*;

	// 不允许进行隐式类型转换，只能用构造函数的显式写法
	explicit My_unique_ptr(elem_ptr p)
		:m_ptr_(p)
	{}

	~My_unique_ptr() {
		delete m_ptr_;
	}
	
	My_unique_ptr(const My_unique_ptr&) = delete;
	My_unique_ptr& operator=(const My_unique_ptr&) = delete;

private:
	elem_ptr m_ptr_;
};

辅助函数

  • get：返回指向被管理对象的指针
  • reset：替换被管理的对象，释放原来管理的资源，管理新的资源
  • release：释放被管理对象的所有权，即解除智能指针和资源的管理关系
  • swap：交换被管理对象的所有权
  • operator bool() const：检查是否有关联的被管理对象
  • 重载operator*，operator->，访问被管理的对象
// get：返回指向被管理对象的指针
elemPtr get() const {
	return m_ptr_;
}

// reset：替换被管理的对象
void reset(elemPtr p = nullptr) {
	if (m_ptr_ != nullptr) {
		delete m_ptr_;
	}
	m_ptr_ = p;
}

//  release：释放被管理对象的所有权，即解除智能指针和资源的管理关系
elemPtr release() {
	elemPtr tmp = m_ptr_;
	e_ptr_ = nullptr;
	return tmp;
}

// swap：交换被管理对象的所有权
void swap(My_unique_ptr& other) {
	std::swap(m_ptr_, other.m_ptr_);
}
	
// operator bool() const：检查是否有关联的被管理对象
explicit operator bool() const {
	return m_ptr_ != nullptr;
}

//  重载operator * ，operator->，访问被管理的对象
elemType operator*() const{
	return *m_ptr_;
}

elemPtr operator->() const {
	return m_ptr_;
}

右值引用参数的拷贝构造和赋值

// 这里不能像左值引用的形参一样，使用const，因为我们需要把形参引用的对象资源转移到当前对象，如果是const，则无法修改形参管理的对象
My_unique_ptr(My_unique_ptr&& right) {
	m_ptr_ = right.m_ptr_;
	right.m_ptr_ = nullptr;
}

/*
My_unique_ptr& operator=(My_unique_ptr&& right) {
	if (this != &right) {
		delete m_ptr_;          // 先释放原有资源
		m_ptr_ = right.m_ptr_;
		right.m_ptr_ = nullptr;
	}
	return *this;
}
*/

My_unique_ptr& operator=(My_uniqur_ptr&& right){
	if(right != &right){
		reset(right.release());
	}
	return *this;
}

测试代码

int main(){
	My_unique_ptr<Int> p1(new Int(10));
	
	// if(p1.operator bool())
	if (p1) {
		p1->show_value();
	}
	My_unique_ptr<Int> p2(std::move(p1));  // p2管理Int(10)，p1为空
	if (p1) {
		p1->show_value();
	}
	if (p2) {
		p2->show_value();
	}
	return 0;
}

管理对象数组

我们上面写的My_unique_ptr只能管理单个对象，而不能管理对象数组。我们需要提供两个删除器，一个用于删除单个对象，一个用于删除对象数组

template<class T>
struct my_default_deleter{
	void operator()(T* ptr) const {
		delete ptr;
	}
};

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

My_unique_ptr也需要提供两个版本，一个管理单个对象，一个用于管理对象数组

template <class T, class Dx = my_default_deleter<T>>
class My_unique_ptr {
public:
	using elemType = T;
	using elemPtr = T*;
	using deleterType = Dx;

	// 不允许进行隐式类型转换，只能用构造函数的显式写法
	explicit My_unique_ptr(elemPtr p = nullptr)
		:m_ptr_(p)
	{}

	~My_unique_ptr() {
		// delete m_ptr_;
		reset();
	}

	// 这里不能像左值引用的形参一样，使用const，因为我们需要把形参引用的对象资源转移到当前对象，如果是const，则无法转移
	My_unique_ptr(My_unique_ptr&& right) {
		m_ptr_ = right.m_ptr_;
		right.m_ptr_ = nullptr;
	}

	My_unique_ptr& operator=(My_unique_ptr&& right) {
		if (this != &right) {
			reset(right.release());
		}
		return *this;
	}
	
	My_unique_ptr(const My_unique_ptr&) = delete;
	My_unique_ptr& operator=(const My_unique_ptr&) = delete;

	// get：返回指向被管理对象的指针
	elemPtr get() const {
		return m_ptr_;
	}
	deleterType& getDeleter() {
		return m_deleter_;
	}

	const deleterType& getDeleter() const {
		return m_deleter_;
	}

	// reset：替换被管理的对象
	void reset(elemPtr p = nullptr) {
		if (m_ptr_ != nullptr) {
			// delete m_ptr_;
			m_deleter_(m_ptr_);   // m_deleter.operator()(m_ptr_)
		}
		m_ptr_ = p;
	}

	//  release：释放被管理对象的所有权，即解除智能指针和资源的管理关系
	elemPtr release() {
		elemPtr tmp = m_ptr_;
		m_ptr_ = nullptr;
		return tmp;
	}

	// swap：交换被管理对象的所有权
	void swap(My_unique_ptr& other) {
		std::swap(m_ptr_, other.m_ptr_);
		std::swap(m_deleter_, other.m_deleter_);
	}

	// operator bool() const：检查是否有关联的被管理对象
	explicit operator bool() const {
		return m_ptr_ != nullptr;
	}

	//  重载operator * ，operator->，访问被管理的对象
	elemType operator*() const{
		return *m_ptr_;
	}

	elemPtr operator->() const {
		return m_ptr_;
	}

private:
	elemPtr m_ptr_;
	deleterType m_deleter_;
};


template <class T, class Dx>
class My_unique_ptr<T[], Dx> {
public:
	using elemType = T;
	using elemPtr = T*;
	using deleterType = Dx;

	// 不允许进行隐式类型转换，只能用构造函数的显式写法
	explicit My_unique_ptr(elemPtr p = nullptr)
		:m_ptr_(p)
	{}

	~My_unique_ptr() {
		// delete m_ptr_;
		reset();
	}

	// 这里不能像左值引用的形参一样，使用const，因为我们需要把形参引用的对象资源转移到当前对象，如果是const，则无法转移
	My_unique_ptr(My_unique_ptr&& right) {
		m_ptr_ = right.m_ptr_;
		right.m_ptr_ = nullptr;
	}

	My_unique_ptr& operator=(My_unique_ptr&& right) {
		if (this != &right) {
			reset(right.release());
		}
		return *this;
	}

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

	// get：返回指向被管理对象的指针
	elemPtr get() const {
		return m_ptr_;
	}
	deleterType& getDeleter() {
		return m_deleter_;
	}

	const deleterType& getDeleter() const {
		return m_deleter_;
	}

	// reset：替换被管理的对象
	void reset(elemPtr p = nullptr) {
		if (m_ptr_ != nullptr) {
			// delete m_ptr_;
			m_deleter_(m_ptr_);   // m_deleter.operator()(m_ptr_)
		}
		m_ptr_ = p;
	}

	//  release：释放被管理对象的所有权，即解除智能指针和资源的管理关系
	elemPtr release() {
		elemPtr tmp = m_ptr_;
		m_ptr_ = nullptr;
		return tmp;
	}

	// swap：交换被管理对象的所有权
	void swap(My_unique_ptr& other) {
		std::swap(m_ptr_, other.m_ptr_);
		std::swap(m_deleter_, other.m_deleter_);
	}

	// operator bool() const：检查是否有关联的被管理对象
	explicit operator bool() const {
		return m_ptr_ != nullptr;
	}

	elemType operator*() = delete;
	elemPtr operator->() = delete;

	elemType& operator[](std::size_t i) const {
		return m_ptr_[i];
	}

private:
	elemPtr m_ptr_;
	deleterType m_deleter_;
};

int main(){
	My_unique_ptr<Int[]> p1(new Int[3]);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

用My_unique_ptr管理数组的时候，会使用使用数组模板类型的My_unique_ptr，并找到默认删除器，还会把当前数组类型加入到删除器的模板参数，使用删除数组的删除器

管理非heap区资源

添加文件删除器对象

template <>
struct my_default_deleter <FILE> {
	void operator()(FILE* fp) const {
		fclose(fp);
	}
};

int main() {
	My_unique_ptr<FILE> fp(fopen("1.txt", "w"));
	if (!fp) {
		exit(1);
	}
	fprintf(fp.get(), "%d %d %d", 1, 2, 3);
	return 0;
}

在这里插入图片描述

或者添加带有删除器对象的构造函数

My_unique_ptr(elemPtr p, const Dx& deleter)
	: m_ptr_(p)
	, m_deleter_(std::move(deleter))
{}

// 不写template<> 编译不过，删除器对象需要和My_unique_ptr底层的m_deleter_对象的类型相同
template <>
struct my_default_deleter <FILE> {
	void operator()(FILE* fp) const {
		fclose(fp);
	}
};


int main() {
	My_unique_ptr<FILE> fp(fopen("1.txt", "w"), my_default_deleter <FILE>());
	if (!fp) {
		exit(1);
	}
	fprintf(fp.get(), "%d %d %d", 1, 2, 3);

	return 0;
}

在这里插入图片描述

使用unique_ptr总结

unique_ptr在表达“专属所有权”的语义时使用，即unique_ptr永远拥有其指向的对象，所以unique_ptr是一个move-only类型。unique_ptr指针无法复制，只能将所有权在两个unique_ptr之间转移，转移后原来的unique_ptr被置为NULL

  • 语义简单，即当确定指针管理的对象不能被共享时，使用unique_ptr
  • unique_ptr效率比shared_ptr高，无需维护引用计数控制块
  • 在需要时，可以将unique_ptr转换成shared_ptr

资源会在多个unique_ptr之间转移，最终最后的unique_ptr管理资源，其他的unique_ptr都为NULL

My_unique_ptr<Int> fun(int a) {
	My_unique_ptr<Int> pa(new Int(a));
	return pa;
}

int main() {
	My_unique_ptr<Int> p = fun(1);
	return 0;
}

Int(int value)                                   // 构造Int对象
My_unique_ptr(elemPtr p = nullptr)               // 构造pa
My_unique_ptr(My_unique_ptr&& right)             // 直接构造p，unique_ptr调用右值引用参数的拷贝构造，原来的指针为nullptr
~My_unique_ptr()                                 // 析构pa
~My_unique_ptr()                                 // 析构p
~Int()

智能指针是比裸指针更智能的类，解决悬挂指针、多次释放空间、内存泄露等问题，通常用来确保指针的寿命和其他指向对象的寿命一致

bugcoder-9905
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用，感兴趣的小伙伴们可以参考一下
智能指针 unique_ptr 详解
热门推荐
顺其自然~专栏
02-22 2万+
一、智能指针 1.什么是智能指针 简单地说，C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。 2.常规指针存在的问题 C++在内存分配、释放和管理方面向程序猿提供了全面的灵活性。但是这种灵活性是把双刃剑，一方面它使C++成为一种功能强大的语言，另一方面它让程序猿能够制造与内存相关的问题，比如内存泄漏。 例如在堆声明和分配的内存，析构方法是否会自动销毁对象，又或是方法结束后需要一个个释放，方法存在很多返回的
C++11：智能指针
weixin_43718250的博客
12-09 476
智能指针
C++11 unique_ptr 智能指针
最新发布
君君的博客
03-30 37
智能指针
【C++11智能指针】unique_ptr概述、初始化、常用操作、返回unique_ptr、指定删除器、尺寸
脚踏实地，仰望星空
02-27 5982
1.unique_ptr概述 2.unique_ptr的初始化 2.1 直接初始化 2.2 make_unique函数 3.unique_ptr不支持拷贝构造和拷贝赋值 4.unique_ptr支持移动构造和移动赋值 5.unique_ptr的常用操作 6.返回unique_ptr 7.指定删除器 8.unique_ptr的尺寸
C++11：智能指针（一）
bigger_belief的博客
06-02 1637
介绍智能指针、以及介绍unique_ptr、weak_ptr、weak_ptr这3个智能指针的使用
【C++11智能指针】unique_ptr
Nine_CC的博客
02-13 1197
unique_ptr概述、初始化、常用函数release() 、reset()、get()、swap()、返回unique_ptr、删除器、大小
C++11智能指针中的 unique_ptr实例详解
08-19
unique是独特的、唯一的意思，故名思议，unique_ptr可以“独占”地拥有它所指向的对象，它提供一种严格意义上的所有权。这篇文章主要介绍了C++11智能指针中的 unique_ptr实例详解,需要的朋友可以参考下
智能指针unique_ptr的用法
12-22
　unique_ptr是独占型的智能指针，它不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique_ptr赋值给另一个unique_ptr，如下面错误用法： 　std::unique_ptr<T> myPtr(new T); 　std::unique_ptr...
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
四种智能指针的使用、机制和缺陷分析
C++11 智能指针 unique_ptr
小立仔
05-29 3970
C++11 智能指针 unique_ptr的简介、使用以及其实现原理
C++11新特性——智能指针之unique_ptr
m0_67168421的博客
12-12 1439
C++11
unique_ptr简单实现和析构函数delete指针的原因
weixin_44754004的博客
08-31 1158
https://blog.csdn.net/weixin_48063338/article/details/107578684
C++11中的智能指针
weixin_53260189的博客
04-17 339
在C++中，有三种智能指针，分别是：unique_ptr、shared_ptr和weak_ptr。这三种智能指针都是在STL的头文件< memory> 中定义的，可以在C++11及其以上版本中使用。总之，选择何种智能指针取决于具体场景。如果需要拥有对象的独占权，那么应该选择unique_ptr；如果需要共享对象所有权，那么应该选择shared_ptr；如果需要打破shared_ptr循环引用，那么应该选择weak_ptr。
【C++11】智能指针
weixin_60478154的博客
04-02 5995
【C++11】智能指针
c++ 智能指针unique_ptr 详解
qq_18626745的博客
08-24 2061
unqiue_ptr基础讲解
Unique_ptr
m0_57719144的博客
06-10 855
一、unique_ptrunique_ ptr实现了独享被管理对象指针的概念，这意味这它可确保一个对象和其对应的资源同一时间只被一个unique_ ptr对象拥有。一旦拥有者 被销毁或者变成empty或者开始拥有另一个对象的地址，先前拥有的那个对象就会被销毁，其任何相应资源亦会被释放。1、unique_ptr对象不能进行复制操作只能进行移动操作。2、unique是独特的、唯一的意思，故名思议，unique_ptr可以\"独占\"地拥有它所指向的对象。
C++基础知识 - unique_ptr 使用详解 (C++11)
骆驼胡杨的博客
03-11 2646
unique_ptr 使用详解 (C++11) C++11用更严谨的unique_ptr 取代了auto_ptr！ unique_ptr特性 基于排他所有权模式：两个指针不能指向同一个资源 无法进行左值unique_ptr复制构造，也无法进行左值复制赋值操作，但允许临时 右值赋值构造和赋值 保存指向某个对象的指针，当它本身离开作用域时会自动释放它指向的对象。 在容器中保存指针是安全的 //弊端1. auto_ptr 被C++11 抛弃的主要理由 p1= p2 ,复制或赋值都会改变资源的所有权
C++的智能指针unique_ptr
08-18
C++的std::unique_ptr是一种独占所有权的智能指针。它提供了对动态分配对象的独占所有权，并在其生命周期结束时自动释放所管理的对象。 使用std::unique_ptr时，只能有一个指针指向同一个对象，它不能被复制或拷贝...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bugcoder-9905

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

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

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

打赏作者

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

抵扣说明：

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

余额充值