智能指针unique_ptr

已于 2024-01-06 15:47:42 修改
阅读量850 收藏 16
点赞数 27
分类专栏： c++标准库基础 文章标签： c++
于 2024-01-05 21:41:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lucy_stone/article/details/135182325
版权

unique_ptr通过指针占有并管理另一个对象（主要负责管理对象的销毁，或者说生命周期）。当unique_ptr被销毁时或者给unique_ptr赋值另一个对象的指针时，unique_ptr将删除原来管理的对象。unique_ptr可以管理单个对象，也可以管理动态分配的对象数组。unique_ptr类满足可移动构造以及可移动赋值，但是不满足可复制构造和可复制赋值的要求。

代码库：

https://gitee.com/gamestorm577/CppStd

创建unique_ptr

一般通过std::make_unique来创建一个unique_ptr。

例如创建一个管理单个类对象的unique_ptr：

struct MyStruct
{
    MyStruct()
    {
        printf("MyStruct1, {X: %d, Y: %d}\n", X, Y);
    }
    MyStruct(int x, int y)
        : X(x)
        , Y(y)
    {
        printf("MyStruct2, {X: %d, Y: %d}\n", X, Y);
    }
    int X = 0;
    int Y = 0;
};

std::cout << "construct a unique_ptr of single object: " << std::endl;
std::unique_ptr<MyStruct> ptr1 = std::make_unique<MyStruct>();

std::cout << "construct a unique_ptr of single object: " << std::endl;
std::unique_ptr<MyStruct> ptr2 = std::make_unique<MyStruct>(3, 5);

终端输出结果为：

construct a unique_ptr of single object: 
MyStruct1, {X: 0, Y: 0}
construct a unique_ptr of single object: 
MyStruct2, {X: 3, Y: 5}

也可以创建一个管理动态分配的对象数组的unique_ptr：

std::cout << "construct a unique_ptr of object array: " << std::endl;
std::unique_ptr<MyStruct[]> ptr3 = std::make_unique<MyStruct[]>(3);

终端输出结果为：

construct a unique_ptr of object array: 
MyStruct1, {X: 0, Y: 0}
MyStruct1, {X: 0, Y: 0}
MyStruct1, {X: 0, Y: 0}

对象生命周期管理

智能指针的主要功能是管理对象的生命周期。对于一个动态分配的对象，当我们不需要时，需要手动删除这个对象，这种手动管理的方式非常容易犯错。unique_ptr是一个栈上的变量，它的内存申请和回收都是系统自动完成的。通过unique_ptr来管理动态分配的对象的生命周期，当unique_ptr被销毁时，自动删除其占用的对象，这样更智能，不容易犯错。

例如，当unique_ptr离开作用域时，unique_ptr被销毁，unique_ptr管理的对象被自动删除：

struct MyStruct
{
    ~MyStruct()
    {
        printf("~MyStruct\n");
    }
};

{
    std::unique_ptr<MyStruct> ptr = std::make_unique<MyStruct>();
    printf("About to leave scope\n");
}
printf("Enter new scope\n");

终端输出结果为：

About to leave scope
~MyStruct
Enter new scope

unique_ptr也是异常安全的，当unique_ptr离开作用域前抛出异常时，也能正常删除占有的对象：

struct MyStruct
{
    ~MyStruct()
    {
        printf("~MyStruct\n");
    }
};

try
{
    std::unique_ptr<MyStruct> ptr = std::make_unique<MyStruct>();
    printf("About to throw\n");
    throw std::exception();
    printf("After to throw\n");
}
catch (std::exception e)
{
    printf("Catch\n");
}

终端输出结果为：

About to throw
~MyStruct
Catch

在ptr离开作用域前就抛出了异常，但是在进入catch之前Mystruct的析构函数还是被正常调用了 

自定义Deleter

unique_ptr也可以自定义Deleter

struct MyStruct
{
    ~MyStruct()
    {
        printf("~MyStruct\n");
    }
};

struct Deleter
{
    void operator()(MyStruct* p) const
    {
        printf("Deleter\n");
        delete p;
    }
};

{
    printf("ptr1: \n");
    std::unique_ptr<MyStruct> ptr1 = std::make_unique<MyStruct>();
}

{
    printf("ptr2: \n");
    std::unique_ptr<MyStruct, Deleter> ptr2(new MyStruct);
}

终端输出结果为：

ptr1: 
~MyStruct
ptr2: 
Deleter
~MyStruct

访问对象

当unique_ptr管理的是单个对象时，可以使用重载操作符 operator* 来获取管理的对象，或者通过重载操作符 operator-> 来直接访问对象的成员：

struct MyStruct
{
    void Test()
    {
        printf("MyStruct::Test\n");
    }
};

printf("single object\n");
std::unique_ptr<MyStruct> ptr1 = std::make_unique<MyStruct>();
MyStruct& s1 = *ptr1;
s1.Test();
ptr1->Test();

输出结果为：

single object
MyStruct::Test
MyStruct::Test

当unique_ptr管理的是对象数组时，可以通过重载操作符 operator[] 来获取管理的对象:

printf("object array\n");
std::unique_ptr<MyStruct[]> ptr2 = std::make_unique<MyStruct[]>(5);
for (int i = 0; i < 5; ++i)
{
    MyStruct& s = ptr2[i];
    s.Test();
}

输出结果为：

object array
MyStruct::Test
MyStruct::Test
MyStruct::Test
MyStruct::Test
MyStruct::Test

其他接口

移动赋值函数

通过移动赋值函数，可以将对象的所有权从一个unique_ptr移交给另一个unique_ptr。对象的生命周期也从跟随原unique_ptr到跟随目标unique_ptr。例如：

struct MyStruct
{
    MyStruct(int id)
        : ID(id)
    {
        printf("MyStruct, id = %d\n", ID);
    }
    ~MyStruct()
    {
        printf("~MyStruct, id = %d\n", ID);
    }
    int ID = 0;
};

{
    printf("test1: \n");
    printf("Enter outer scope\n");
    std::unique_ptr<MyStruct> ptr1 = nullptr;
    {
        printf("Enter inner scope\n");
        std::unique_ptr<MyStruct> ptr2 = std::make_unique<MyStruct>(1);
        ptr1 = std::move(ptr2);
        printf("Leave inner scope\n");
    }
    printf("Leave outer scope\n");
}

输出结果为：

test1: 
Enter outer scope
Enter inner scope
MyStruct, id = 1
Leave inner scope
Leave outer scope
~MyStruct, id = 1

ptr2将对象的所有权移交给ptr1，当ptr2的作用域结束时，对象并没有被删除，而只有当ptr1的作用域结束时，对象才被删除。

当被移交的目标unique_ptr不为空时，目标unique_ptr原有的对象会被删除。例如：

{
    printf("test2: \n");
    std::unique_ptr<MyStruct> ptr1 = std::make_unique<MyStruct>(1);
    std::unique_ptr<MyStruct> ptr2 = std::make_unique<MyStruct>(5);
    printf("start move ptr2 to ptr1\n");
    ptr1 = std::move(ptr2);
    printf("end move ptr2 to ptr1\n");
}

输出结果为：

MyStruct, id = 1
MyStruct, id = 5
start move ptr2 to ptr1
~MyStruct, id = 1
end move ptr2 to ptr1
~MyStruct, id = 5

当ptr2将对象移交给ptr1时，ptr1的作用域并没有结束，但是ptr1只能占有一个对象，所以原来占有的对象将被删除。

get

返回管理对象的指针，例如：

std::unique_ptr<double> ptr = std::make_unique<double>(20.5);
double* val = ptr.get();
printf("number = %.3f\n", *val);

输出结果为：

number = 20.500
Program ended with exit code: 0

get_deleter

获取unique_ptr的deleter，例如：

struct MyStruct
{
};

struct Deleter
{
    void Test()
    {
        printf("Deleter::Test\n");
    }

    void operator()(MyStruct* p) const
    {
        delete p;
    }
};

std::unique_ptr<MyStruct, Deleter> ptr(new MyStruct);
auto& del = ptr.get_deleter();
del.Test();

输出结果为：

Deleter::Test

operator bool

判断unique_ptr是否占有对象，例如：

auto Func = [](const std::unique_ptr<int>& ptr) -> void
{
    if (ptr)
    {
        printf("ptr not empty\n");
    }
    else
    {
        printf("ptr empty\n");
    }
};

std::unique_ptr<int> ptr1 = std::make_unique<int>();
std::unique_ptr<int> ptr2 = nullptr;
Func(ptr1);
Func(ptr2);

输出结果为：

ptr not empty
ptr empty

release

unique_ptr不再占用管理的对象并返回该对象的指针，如果管理的是空对象则返回nullptr，例如：

struct MyStruct
{
    ~MyStruct()
    {
        printf("~MyStruct\n");
    }
};

{
    std::unique_ptr<MyStruct> ptr = std::make_unique<MyStruct>();
    MyStruct* tmp = ptr.release();
    printf("About to enter outer scope\n");
}
printf("Enter outer scope\n");

输出结果为：

About to enter outer scope
Enter outer scope

调用release接口后，ptr不再占用对象，也不再负责对象的生命周期，所以当ptr离开作用域时，并没有删除对象。

reset

删除旧的对象，替换新的对象，例如：

struct MyStruct
{
    MyStruct(int id)
        : ID(id)
    {
    }

    ~MyStruct()
    {
        printf("~MyStruct, id = %d\n", ID);
    }

    int ID = 0;
};

MyStruct* tmp = new MyStruct(20);
std::unique_ptr<MyStruct> ptr = std::make_unique<MyStruct>(5);
ptr.reset(tmp);
printf("finish reset\n");

输出结果为：

~MyStruct, id = 5
finish reset
~MyStruct, id = 20
Program ended with exit code: 0

swap

交换两个unique_ptr管理的对象，例如：

struct MyStruct
{
    MyStruct(int id)
        : ID(id)
    {
    }

    void Test()
    {
        printf("Test, id = %d\n", ID);
    }

    int ID = 0;
};

std::unique_ptr<MyStruct> ptr1 = std::make_unique<MyStruct>(5);
std::unique_ptr<MyStruct> ptr2 = std::make_unique<MyStruct>(20);
ptr1->Test();
ptr2->Test();
ptr1.swap(ptr2);
ptr1->Test();
ptr2->Test();

输出结果为：

Test, id = 5
Test, id = 20
Test, id = 20
Test, id = 5

operator<<

输出unique_ptr管理对象的指针的值到输出流中，例如：

std::unique_ptr<int> ptr = std::make_unique<int>(5);
std::cout << ptr << std::endl;
0x600000008040

unique_ptr的比较

==、!=、<、<=、>、>=、<=>等符号可用于两个unique_ptr或者unique_ptr与nullptr的比较，比较的值是unique_ptr管理对象的指针的值，例如：

std::unique_ptr<int> ptr1 = std::make_unique<int>(5);
std::unique_ptr<int> ptr2 = std::make_unique<int>(5);
std::cout << "ptr1 == ptr1: " << (ptr1 == ptr1) << std::endl;
std::cout << "ptr1 == ptr2: " << (ptr1 == ptr2) << std::endl;

hash

计算对象的散列值，例如：

struct MyStruct
{
};

MyStruct* tmp = new MyStruct;
std::unique_ptr<MyStruct> ptr(tmp);
std::cout << std::hash<std::unique_ptr<MyStruct>>()(ptr) << std::endl;
std::cout << std::hash<MyStruct*>()(tmp) << std::endl;

输出结果为：

12022488372033534701
12022488372033534701
Lucy_stone
关注
  • 27
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
智能指针 unique_ptr 详解
热门推荐
顺其自然~专栏
02-22 2万+
一、智能指针 1.什么是智能指针 简单地说，C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。 2.常规指针存在的问题 C++在内存分配、释放和管理方面向程序猿提供了全面的灵活性。但是这种灵活性是把双刃剑，一方面它使C++成为一种功能强大的语言，另一方面它让程序猿能够制造与内存相关的问题，比如内存泄漏。 例如在堆声明和分配的内存，析构方法是否会自动销毁对象，又或是方法结束后需要一个个释放，方法存在很多返回的
C++智能指针unique_ptr
weixin_44651073的博客
02-26 538
智能指针unique_ptr语法详解
C++11 智能指针 unique_ptr
小立仔
05-29 4117
C++11 智能指针 unique_ptr的简介、使用以及其实现原理
C++11智能指针unique_ptr剖析
长期更新Java自学笔记
09-05 458
unique_ptr实现了独享被管理对象指针的概念，这意味着它可以确保一个对象和其对应的资源同一时间只被一个unique_ptr对象拥有。
C++智能指针unique_ptr与shared_ptr
喜欢打篮球的普通人
12-01 6201
文章目录1.unique_ptr特点2.unique_ptr例子3.unique_ptr总结4.shared_ptr特点5.shared_ptr例子6.shared_ptr中的自定义删除器 Deleter7.shared_ptr 相对于普通指针的优缺点 1.unique_ptr特点 unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现，独享被管理对象指针所有权的智能指针。 unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联
智能指针unique_ptr的用法
12-22
此文描述了智能指针unique_ptr的用法的相关介绍，具体实例请看下文 　unique_ptr是独占型的智能指针，它不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique_ptr赋值给另一个unique_ptr，如下面错误...
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
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
unique是独特的、唯一的意思，故名思议，unique_ptr可以“独占”地拥有它所指向的对象，它提供一种严格意义上的所有权。这篇文章主要介绍了C++11智能指针中的 unique_ptr实例详解,需要的朋友可以参考下
C++ 中使用lambda代替 unique_ptr 的Deleter的方法
08-30
在C++编程中，`std::unique_ptr`是一种智能指针，它负责管理动态分配的对象，并在不再需要对象时自动释放内存。`unique_ptr`的一个关键特性是它的删除器（Deleter），这是一个用于销毁所指向对象的函数或函数对象。...
C语言第17篇：预处理详解
2302_78977491的博客
06-22 769
C语言设置了一些预定义符号，可以直接使用。预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1, 否则未定义int main()printf("进行编译的源文件:%s\n", __FILE__);printf("当前文件的行号:%d\n", __LINE__);
C++之STL（十二）
最新发布
CSDN_HZW的博客
06-27 119
【代码】C++之STL（十二）
C++精解【7】
应用数学
06-27 792
使用一种存储顺序的矩阵和数组可以分配给使用另一种存储顺序的矩阵和数组，就像上面的程序中使用Acolmajor初始化Arowmajor时发生的那样。3.缺省情况下，Eigen是列为主的。这意味着，尽管我们的目标是透明地支持列为主和行为主的存储顺序，但Eigen库可能最适合列为主的矩阵。2.当矩阵以行为主的顺序存储时，由于更好的数据局部性，逐行遍历矩阵的算法将运行得更快。为了找出适合您的特定应用程序的更快的方法，进行一些实验可能是值得的。或者，您可以使用Eigen以外的其他库，这些库可能需要特定的存储顺序。
C++ 内存分配可视化
一个大佬的博客
06-24 652
注：宽度表示生存时间(黑色表示泄漏)，高度表示内存占用大小，颜色表示每次调用地址。
什么野指针（c++）
qq_35374791的博客
06-24 6454
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
makefile文件编写（C）
baidu_34971492的博客
06-24 218
这个Makefile定义了如何编译和链接你的程序。CC变量指定了编译器（这里是gcc），CFLAGS变量包含了编译器的标志，比如警告选项和调试信息，LDFLAGS变量用于链接时的选项。运行Makefile：在命令行中运行make命令，Makefile会根据其规则自动编译和链接你的程序。
C++ TheadPool 线程池实现
GodJhin的博客
06-21 837
此情况发生情形3且设置了任务缓冲队列大小后面，主程序添加第N个任务，添加后发现池子中的线程用完了，任务缓冲队列也满了，于是进入等待状态、等待任务缓冲队列中的任务腾空通知。此情况基于情形1，所有工作线程已处在等待状态，主线程开始添加三个任务，添加后通知(notif())唤醒线程池中的线程开始取(take())任务执行. 此时的任务缓冲队列还是空。此情况发生情形2后面，所有工作线程都在工作中，主线程开始添加第四个任务，添加后发现现在线程池中的线程用完了，于是存入任务缓冲队列。
c++ 智能指针 unique_ptr
07-25
unique_ptr 是 C++ 中的智能指针，用于管理动态分配的对象。它的特点是独占资源，即同一时间只能有一个 unique_ptr 指向同一个对象，确保了资源的独占性和自动释放。当 unique_ptr 被销毁或者重置时，它所管理的对象也会被自动释放。 unique_ptr 的使用相对简单，可以通过以下方式创建一个 unique_ptr 对象： ``` std::unique_ptr<DataType> ptr = std::make_unique<DataType>(args); ``` 其中，DataType 是指向的对象类型，args 是用于构造 DataType 对象的参数。 unique_ptr 还提供了一些常用的操作方法，比如访问指针所指的对象可以使用 `*` 或者 `->` 运算符，重置指针可以使用 `reset` 方法，获取指针可以使用 `get` 方法等等。此外，unique_ptr 还支持移动语义，可以通过 `std::move` 将 unique_ptr 转移给其他 unique_ptr。 需要注意的是，unique_ptr 不支持复制语义，即不能直接进行复制操作。如果需要共享资源，可以考虑使用 shared_ptr。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值