C++智能指针unique_ptr与shared_ptr

2024-06-08 05:18
文章标签 c++ 指针 智能 shared unique ptr

本文主要是介绍C++智能指针unique_ptr与shared_ptr，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 1.unique_ptr特点
    • 2.unique_ptr例子
    • 3.unique_ptr总结
    • 4.shared_ptr特点
    • 5.shared_ptr例子
    • 6.shared_ptr中的自定义删除器 Deleter
    • 7.shared_ptr 相对于普通指针的优缺点

1.unique_ptr特点

unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现，独享被管理对象指针所有权的智能指针。

  • unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。
  • unique_ptr具有->和*运算符重载符，因此它可以像普通指针一样使用。

unique_ptr 独享所有权

  • unique_ptr对象始终是关联的原始指针的唯一所有者。我们无法复制unique_ptr对象，它只能移动。
  • 由于每个unique_ptr对象都是原始指针的唯一所有者，因此在其析构函数中它直接删除关联的指针，不需要任何参考计数。

创建一个空的 unique_ptr 对象

  • 创建一个空的unique_ptr对象，因为没有与之关联的原始指针，所以它是空的。
std::unique_ptr<int> ptr1;

检查 unique_ptr 对象是否为空

  • 有两种方法可以检查 unique_ptr 对象是否为空或者是否有与之关联的原始指针。
// 方法1
if(!ptr1)std::cout<<"ptr1 is empty"<<std::endl;
// 方法2
if(ptr1 == nullptr)std::cout<<"ptr1 is empty"<<std::endl;

使用原始指针创建 unique_ptr 对象

  • 要创建非空的 unique_ptr 对象，需要在创建对象时在其构造函数中传递原始指针，即：
std::unique_ptr<Task> taskPtr(new Task(22));
std::unique_ptr<Task> taskPtr(new std::unique_ptr<Task>::element_type(23));不能通过赋值的方法创建对象，下面的这句是错误的
// std::unique_ptr<Task> taskPtr2 = new Task(); // 编译错误

使用 std::make_unique 创建 unique_ptr 对象 / C++14

  • std::make_unique<>() 是C++ 14 引入的新函数
std::unique_ptr<Task> taskPtr = std::make_unique<Task>(34);

获取被管理对象的指针

  • 使用get()·函数获取管理对象的指针。
Task *p1 = taskPtr.get();

重置 unique_ptr 对象

  • 在 unique_ptr 对象上调用reset()函数将重置它
    即它将释放delete关联的原始指针并使unique_ptr 对象为空。
taskPtr.reset();

unique_ptr 对象不可复制

  • 由于 unique_ptr 不可复制，只能移动。
    因此，我们无法通过复制构造函数或赋值运算符创建unique_ptr对象的副本。
// 编译错误 : unique_ptr 不能复制
std::unique_ptr<Task> taskPtr3 = taskPtr2; // Compile error// 编译错误 : unique_ptr 不能复制
taskPtr = taskPtr2; //compile error

转移 unique_ptr 对象的所有权

  • 我们无法复制 unique_ptr 对象，但我们可以转移它们。
    这意味着 unique_ptr 对象可以将关联的原始指针的所有权转移到另一个 unique_ptr 对象。
  • 让我们通过一个例子来理解：
    std::move() 将把 taskPtr2 转换为一个右值引用。
    因此，调用 unique_ptr 的移动构造函数，并将关联的原始指针传输到 taskPtr4。在转移完原始指针的所有权后， taskPtr2将变为空。
// 通过原始指针创建 taskPtr2
std::unique_ptr<Task> taskPtr2(new Task(55));// 把taskPtr2中关联指针的所有权转移给taskPtr4
std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);// 现在taskPtr2关联的指针为空
if(taskPtr2 == nullptr)std::cout<<"taskPtr2 is  empty"<<std::endl;// taskPtr2关联指针的所有权现在转移到了taskPtr4中
if(taskPtr4 != nullptr)std::cout<<"taskPtr4 is not empty"<<std::endl;// 会输出55
std::cout<< taskPtr4->mId << std::endl;

释放关联的原始指针

  • 在 unique_ptr 对象上调用 release()将释放其关联的原始指针的所有权，并返回原始指针。这里是释放所有权，并没有delete原始指针，reset()会delete原始指针。
std::unique_ptr<Task> taskPtr5(new Task(55));// 不为空
if(taskPtr5 != nullptr)std::cout<<"taskPtr5 is not empty"<<std::endl;// 释放关联指针的所有权
Task * ptr = taskPtr5.release();// 现在为空
if(taskPtr5 == nullptr)std::cout<<"taskPtr5 is empty"<<std::endl;

2.unique_ptr例子

eg1:

#include <iostream>
#include <memory>struct Task {int mId;Task(int id ) :mId(id) {std::cout << "Task::Constructor" << std::endl;}~Task() {std::cout << "Task::Destructor" << std::endl;}
};int main()
{// 通过原始指针创建 unique_ptr 实例std::unique_ptr<Task> taskPtr(new Task(23));//通过 unique_ptr 访问其成员int id = taskPtr->mId;std::cout << id << std::endl;return 0;
}

输出
在这里插入图片描述
unique_ptr 对象 taskPtr 接受原始指针作为参数。

  • 当main函数退出时，该对象超出作用范围就会调用其析构函数，在unique_ptr对象taskPtr 的析构函数中，会删除关联的原始指针，这样就不用专门delete Task对象了。
  • 这样不管函数正常退出还是异常退出（由于某些异常），也会始终调用taskPtr的析构函数。因此，原始指针将始终被删除并防止内存泄漏

eg2：

#include <iostream>
#include <memory>struct Task {int mId;Task(int id) :mId(id) {std::cout << "Task::Constructor" << std::endl;}~Task() {std::cout << "Task::Destructor" << std::endl;}
};int main()
{// 空对象 unique_ptrstd::unique_ptr<int> ptr1;// 检查 ptr1 是否为空if (!ptr1)std::cout << "ptr1 is empty" << std::endl;// 检查 ptr1 是否为空if (ptr1 == nullptr)std::cout << "ptr1 is empty" << std::endl;// 不能通过赋值初始化unique_ptr// std::unique_ptr<Task> taskPtr2 = new Task(); // Compile Error// 通过原始指针创建 unique_ptrstd::unique_ptr<Task> taskPtr(new Task(23));// 检查 taskPtr 是否为空if (taskPtr != nullptr)std::cout << "taskPtr is  not empty" << std::endl;// 访问 unique_ptr关联指针的成员std::cout << taskPtr->mId << std::endl;std::cout << "Reset the taskPtr" << std::endl;// 重置 unique_ptr 为空，将删除关联的原始指针taskPtr.reset();// 检查是否为空 / 检查有没有关联的原始指针if (taskPtr == nullptr)std::cout << "taskPtr is  empty" << std::endl;// 通过原始指针创建 unique_ptrstd::unique_ptr<Task> taskPtr2(new Task(55));if (taskPtr2 != nullptr)std::cout << "taskPtr2 is  not empty" << std::endl;// unique_ptr 对象不能复制//taskPtr = taskPtr2; //compile error//std::unique_ptr<Task> taskPtr3 = taskPtr2;{// 转移所有权（把unique_ptr中的指针转移到另一个unique_ptr中）std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);// 转移后为空if (taskPtr2 == nullptr)std::cout << "taskPtr2 is  empty" << std::endl;// 转进来后非空if (taskPtr4 != nullptr)std::cout << "taskPtr4 is not empty" << std::endl;std::cout << taskPtr4->mId << std::endl;//taskPtr4 超出下面这个括号的作用于将delete其关联的指针}std::unique_ptr<Task> taskPtr5(new Task(66));if (taskPtr5 != nullptr)std::cout << "taskPtr5 is not empty" << std::endl;// 释放所有权Task * ptr = taskPtr5.release();if (taskPtr5 == nullptr)std::cout << "taskPtr5 is empty" << std::endl;std::cout << ptr->mId << std::endl;delete ptr;return 0;
}

在这里插入图片描述

3.unique_ptr总结

new出来的对象是位于堆内存上的，必须调用delete才能释放其内存。

  • unique_ptr 是一个装指针的容器，且拥有关联指针的唯一所有权，作为普通变量使用时系统分配对象到栈内存上，超出作用域时会自动析构，unique_ptr对象的析构函数中会delete其关联指针，这样就相当于替我们执行了delete堆内存上的对象。

  • unique_ptr不能直接复制，必须使用std::move()转移其管理的指针，转移后原 unique_ptr 为空。std::unique_ptr taskPtr4 = std::move(taskPtr2);

成员函数作用
reset()重置unique_ptr为空，delete其关联的指针。
release()不delete关联指针，并返回关联指针。释放关联指针的所有权，unique_ptr为空。
get()仅仅返回关联指针

4.shared_ptr特点

shared_ptr 是C++11提供的一种智能指针类，它足够智能，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏和悬空指针的问题。

  • 它遵循共享所有权的概念，即不同的 shared_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。

  • 每个 shared_ptr 对象在内部指向两个内存位置：
    1、指向对象的指针。
    2、用于控制引用计数数据的指针。

  • 共享所有权如何在参考计数的帮助下工作：
    1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。
    2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。

创建 shared_ptr 对象

  • 使用原始指针创建 shared_ptr 对象
    这行代码在堆上创建了两块内存：
    1：存储int。
    2：用于引用计数的内存，管理附加此内存的 shared_ptr 对象的计数，最初计数将为1。
std::shared_ptr<int> p1(new int());

检查 shared_ptr 对象的引用计数

p1.use_count();

创建空的 shared_ptr 对象

  • 因为带有参数的 shared_ptr 构造函数是 explicit 类型的，所以不能像这样std::shared_ptr p1 = new int();隐式调用它构造函数。
    创建新的shared_ptr对象的最佳方法是使用std :: make_shared：
    std::make_shared 一次性为int对象和用于引用计数的数据都分配了内存，而new操作符只是为int分配了内存。
std::shared_ptr<int> p1 = std::make_shared<int>();

分离关联的原始指针

  • 要使 shared_ptr 对象取消与相关指针的关联，可以使用reset()函数：
    不带参数的reset()：
    它将引用计数减少1，如果引用计数变为0，则删除指针。
p1.reset();

带参数的reset()：

  • 在这种情况下，它将在内部指向新指针，因此其引用计数将再次变为1。
p1.reset(new int(34));

使用nullptr重置：

p1 = nullptr;

shared_ptr是一个伪指针

  • shared_ptr充当普通指针，我们可以将*和->与 shared_ptr 对象一起使用，也可以像其他 shared_ptr 对象一样进行比较;

5.shared_ptr例子

eg1：

#include <iostream>
#include  <memory> // 需要包含这个头文件int main()
{// 使用 make_shared 创建空对象std::shared_ptr<int> p1 = std::make_shared<int>();*p1 = 78;std::cout << "p1 = " << *p1 << std::endl; // 输出78// 打印引用个数：1std::cout << "p1 Reference count = " << p1.use_count() << std::endl;// 第2个 shared_ptr 对象指向同一个指针std::shared_ptr<int> p2(p1);// 下面两个输出都是：2std::cout << "p2 Reference count = " << p2.use_count() << std::endl;std::cout << "p1 Reference count = " << p1.use_count() << std::endl;// 比较智能指针，p1 等于 p2if (p1 == p2) {std::cout << "p1 and p2 are pointing to same pointer\n";}std::cout<<"Reset p1 "<<std::endl;// 无参数调用reset，无关联指针，引用个数为0p1.reset();std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;// 带参数调用reset，引用个数为1p1.reset(new int(11));std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;// 把对象重置为NULL，引用计数为0p1 = nullptr;std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;if (!p1) {std::cout << "p1 is NULL" << std::endl; // 输出}return 0;
}

在这里插入图片描述

6.shared_ptr中的自定义删除器 Deleter

自定义删除器 Deleter

  • 当 shared_ptr 对象超出范围时，将调用其析构函数。
    在其析构函数中，它将引用计数减1，如果引用计数的新值为0，则删除关联的原始指针。
  • 析构函数中删除内部原始指针，默认调用的是delete()函数。
delete Pointer;

有些时候在析构函数中，delete函数并不能满足我们的需求，可能还想加其他的处理。
当 shared_ptr 对象指向数组

  • 像这样申请的数组，应该调用delete []释放内存，而shared_ptr析构函数中默认delete并不能满足需求，可以使用shared_ptr<int[]>形式或者添加自定义删除器。
// 需要添加自定义删除器的使用方式
std::shared_ptr<int> p3(new int[12]);   // 仅用于演示自定义删除器// 指向数组的智能指针可以使用这种形式
std::shared_ptr<int[]> p3(new int[12]);  // 正确使用方式

给shared_ptr添加自定义删除器

  • 在上面在这种情况下，我们可以将回调函数传递给 shared_ptr 的构造函数，该回调函数将从其析构函数中调用以进行删除，即

下面看一个完整的示例：

#include <iostream>
#include <memory>struct Sample
{Sample() {std::cout << "Sample\n";}~Sample() {std::cout << "~Sample\n";}
};void deleter(Sample * x)
{std::cout << "Custom Deleter\n";delete[] x;
}int main()
{std::shared_ptr<Sample> p3(new Sample[3], deleter);return 0;
}

在这里插入图片描述
使用Lambda 表达式 / 函数对象作为删除器

class Deleter
{public:void operator() (Sample * x) {std::cout<<"DELETER FUNCTION CALLED\n";delete[] x;}
};// 函数对象作为删除器
std::shared_ptr<Sample> p3(new Sample[3], Deleter());// Lambda表达式作为删除器
std::shared_ptr<Sample> p4(new Sample[3], [](Sample * x){std::cout<<"DELETER FUNCTION CALLED\n";delete[] x;
});

7.shared_ptr 相对于普通指针的优缺点

缺少 ++, – – 和 [] 运算符

  • 与普通指针相比，shared_ptr仅提供-> 、*和==运算符，没有+、-、++、–、[]等运算符。
  • shared_ptr 检测空值方法
    当我们创建 shared_ptr 对象而不分配任何值时，它就是空的；普通指针不分配空间的时候相当于一个野指针，指向垃圾空间，且无法判断指向的是否是有用数据。
  • eg1：
#include<iostream>
#include<memory>struct Sample {void dummyFunction() {std::cout << "dummyFunction" << std::endl;}
};int main()
{std::shared_ptr<Sample> ptr = std::make_shared<Sample>();(*ptr).dummyFunction(); // 正常ptr->dummyFunction(); // 正常// ptr[0]->dummyFunction(); // 错误方式// ptr++;  // 错误方式//ptr--;  // 错误方式std::shared_ptr<Sample> ptr2(ptr);if (ptr == ptr2) // 正常std::cout << "ptr and ptr2 are equal" << std::endl;std::shared_ptr<Sample> ptr3;if (!ptr3)std::cout << "Yes, ptr3 is empty" << std::endl;if (ptr3 == NULL)std::cout << "ptr3 is empty1" << std::endl;if (ptr3 == nullptr)std::cout << "ptr3 is empty2" << std::endl;return 0;
}

在这里插入图片描述

创建 shared_ptr 时注意事项

  • 不要使用同一个原始指针构造 shared_ptr
    创建多个 shared_ptr 的正常方法是使用一个已存在的shared_ptr 进行创建，而不是使用同一个原始指针进行创建。
  • 假如使用原始指针num创建了p1，又同样方法创建了p3，当p1超出作用域时会调用delete释放num内存，此时num成了悬空指针，当p3超出作用域再次delete的时候就可能会出错。
    int *num = new int(23);std::shared_ptr<int> p1(num);std::shared_ptr<int> p2(p1);  // 正确使用方法std::shared_ptr<int> p3(num); // 不推荐std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 输出 2std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 输出 2std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 输出 1
  • 不要用栈中的指针构造 shared_ptr 对象
    shared_ptr 默认的构造函数中使用的是delete来删除关联的指针，所以构造的时候也必须使用new出来的堆空间的指针。
  • 当 shared_ptr 对象超出作用域调用析构函数delete 指针&x时会出错（也不是出错，感觉程序没有停止的意思）。
#include<iostream>
#include<memory>int main()
{int x = 12;std::shared_ptr<int> ptr(&x);return 0;
}

在这里插入图片描述

建议使用 make_shared

  • 为了避免以上两种情形，建议使用make_shared()<>创建 shared_ptr 对象，而不是使用默认构造函数创建。
  • 另外不建议使用get()函数获取 shared_ptr 关联的原始指针，因为如果在 shared_ptr 析构之前手动调用了delete函数，同样会导致类似的错误。
std::shared_ptr<int> ptr_1 = make_shared<int>();
std::shared_ptr<int> ptr_2 (ptr_1);
  • 参考：C++ 智能指针 shared_ptr 详解与示例，C++ 智能指针 unique_ptr 详解与示例

这篇关于C++智能指针unique_ptr与shared_ptr的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1041294。

相关文章

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如下： class A class B1:public virtual A; class B2:pu
阅读更多...
C++对象布局及多态实现探索之内存布局（整理的很多链接）

C++对象布局及多态实现探索之内存布局（整理的很多链接）

本文通过观察对象的内存布局，跟踪函数调用的汇编代码。分析了C++对象内存的布局情况，虚函数的执行方式，以及虚继承，等等 文章链接：http://dev.yesky.com/254/2191254.shtml      论C/C++函数间动态内存的传递 (2005-07-30)   当你涉及到C/C++的核心编程的时候，你会无止境地与内存管理打交道。 文章链接：http://dev.yesky
阅读更多...
C++的模板(八)：子系统

C++的模板(八)：子系统

平常所见的大部分模板代码，模板所传的参数类型，到了模板里面，或实例化为对象，或嵌入模板内部结构中，或在模板内又派生了子类。不管怎样，最终他们在模板内，直接或间接，都实例化成对象了。 但这不是唯一的用法。试想一下。如果在模板内限制调用参数类型的构造函数会发生什么?参数类的对象在模板内无法构造。他们只能从模板的成员函数传入。模板不保存这些对象或者只保存他们的指针。因为构造函数被分离，这些指针在模板外
阅读更多...
C++工程编译链接错误汇总VisualStudio

C++工程编译链接错误汇总VisualStudio

目录 一些小的知识点 make工具 可以使用windows下的事件查看器崩溃的地方 dumpbin工具查看dll是32位还是64位的 _MSC_VER .cc 和.cpp 【VC++目录中的包含目录】 vs 【C/C++常规中的附加包含目录】——头文件所在目录如何怎么添加，添加了以后搜索头文件就会到这些个路径下搜索了 include<> 和 include"" WinMain 和
阅读更多...
C/C++的编译和链接过程

C/C++的编译和链接过程

目录 从源文件生成可执行文件（书中第2章） 1.Preprocessing预处理——预处理器cpp 2.Compilation编译——编译器cll ps：vs中优化选项设置 3.Assembly汇编——汇编器as ps：vs中汇编输出文件设置 4.Linking链接——链接器ld 符号 模块，库 链接过程——链接器 链接过程 1.简单链接的例子 2.链接过程 3.地址和
阅读更多...
C++必修：模版的入门到实践

C++必修：模版的入门到实践

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C++学习 贝蒂的主页：Betty’s blog 1. 泛型编程 首先让我们来思考一个问题，如何实现一个交换函数？ void swap(int& x, int& y){int tmp = x;x = y;y = tmp;} 相信大家很快就能写出上面这段代码，但是如果要求这个交换函数支持字符型
阅读更多...
C++入门01

C++入门01

1、.h和.cpp 源文件 (.cpp)源文件是C++程序的实际实现代码文件，其中包含了具体的函数和类的定义、实现以及其他相关的代码。主要特点如下：实现代码: 源文件中包含了函数、类的具体实现代码，用于实现程序的功能。编译单元: 源文件通常是一个编译单元，即单独编译的基本单位。每个源文件都会经过编译器的处理，生成对应的目标文件。包含头文件: 源文件可以通过#include指令引入头文件，以使
阅读更多...
C++面试八股文：std::deque用过吗？

C++面试八股文：std::deque用过吗？

100编程书屋_孔夫子旧书网 某日二师兄参加XXX科技公司的C++工程师开发岗位第26面： 面试官：deque用过吗？ 二师兄：说实话，很少用，基本没用过。 面试官：为什么？ 二师兄：因为使用它的场景很少，大部分需要性能、且需要自动扩容的时候使用vector，需要随机插入和删除的时候可以使用list。 面试官：那你知道STL中的stack是如何实现的吗？ 二师兄：默认情况下，stack使
阅读更多...
智能客服到个人助理，国内AI大模型如何改变我们的生活？

智能客服到个人助理，国内AI大模型如何改变我们的生活？

引言 随着人工智能（AI）技术的高速发展，AI大模型越来越多地出现在我们的日常生活和工作中。国内的AI大模型在过去几年里取得了显著的进展，不少独创的技术点和实际应用令人瞩目。 那么，国内的AI大模型有哪些独创的技术点？它们在实际应用中又有哪些出色表现呢？此外，普通人又该如何利用这些大模型提升工作和生活的质量和效率呢？本文将为你一一解析。 一、国内AI大模型的独创技术点 多模态学习 多
阅读更多...
C语言入门系列：探秘二级指针与多级指针的奇妙世界

C语言入门系列：探秘二级指针与多级指针的奇妙世界

文章目录 一，指针的回忆杀1，指针的概念2，指针的声明和赋值3，指针的使用3.1 直接给指针变量赋值3.2 通过*运算符读写指针指向的内存3.2.1 读3.2.2 写 二，二级指针详解1，定义2，示例说明3，二级指针与一级指针、普通变量的关系3.1，与一级指针的关系3.2，与普通变量的关系,示例说明 4，二级指针的常见用途5，二级指针扩展到多级指针 小结 C语言的学习之旅中，二级
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2