C++智能指针之unique_ptr

已于 2022-07-15 11:45:38 修改
阅读量886 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2022-07-13 15:11:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35661325/article/details/125764521
版权
本文详细介绍了C++中智能指针unique_ptr的使用，包括其构造函数、析构函数、get、get_deleter、release、reset、swap、赋值运算符以及bool转换运算符等成员函数。unique_ptr作为独占所有权的智能指针，不允许复制，仅支持移动操作，确保了资源的有效管理。通过实例展示了unique_ptr如何管理动态分配的对象，并强调了其在内存管理中的重要性。
摘要由CSDN通过智能技术生成

文章目录

C++智能指针之unique_ptr

unique_ptr篇

简介

unique_ptr是一种定义在 <memory> 中的智能指针，管理指针的存储，提供智能资源回收，并且与内置指针相比几乎没有开销（取决于使用的删除器）。它持有对对象的独有权，即两个unique_ptr不能指向一个对象，不能进行复制操作只能进行移动操作，离开作用域后自动删除指向的对象，或者显示调用 unique_ptr::reset。

成员函数

构造函数
constexpr unique_ptr() noexcept; // 默认构造函数1

std::unique_ptr<int> u1; 

constexpr unique_ptr (nullptr_t) noexcept : unique_ptr() {}  // 默认构造函数2：传入空指针

std::unique_ptr<int> u2 (nullptr);

explicit unique_ptr (pointer p) noexcept; // 传入其它指针

std::unique_ptr<int> u3 (new int);

unique_ptr (pointer p,
    typename conditional<is_reference<D>::value,D,const D&> del) noexcept; // 传入指针和左值删除器

std::default_delete<int> d;
std::unique_ptr<int> u4 (new int, d);

unique_ptr (pointer p,typename remove_reference<D>::type&& del) noexcept; // 传入指针和右值删除器

std::unique_ptr<int> u5 (new int, std::default_delete<int>());

unique_ptr (unique_ptr&& x) noexcept; // 调用move构造
std::unique_ptr<int> u6 (std::move(u5));

template <class U, class E>
    unique_ptr (unique_ptr<U,E>&& x) noexcept; // 调用move右值构造
std::unique_ptr<int> u7 (std::move(u6));// u6->nullptr u7-> u6

template <class U>
  unique_ptr (auto_ptr<U>&& x) noexcept; // 通过移动 auto_ptr 构造, 注意：c++11 已经不支持auto_ptr（c++98）
std::unique_ptr<int> u8 (std::auto_ptr<int>(new int)) 

unique_ptr (const unique_ptr&) = delete; // 拷贝构造

int *p = new int;
*p = 10;
std::unique_ptr<int> u9 (p);
析构函数

如果对象是空（nullptr）则析构无效：

// ~unique_ptr();
// unique_ptr destructor example
#include <iostream>
#include <memory>

int main () {
  auto deleter = [](int*p){
    delete p;
    std::cout << "[deleter called]\n";
  };

  std::unique_ptr<int,decltype(deleter)> foo (new int,deleter);

  std::cout << "foo " << (foo?"is not":"is") << " empty\n";

  return 0;                        // [deleter called]
}
get

返回存储的指针。

pointer get() const noexcept;

#include <iostream>
#include <memory>
int main()
{
  std::unique_ptr<int> foo(new int);
  int *p = nullptr;
  p = foo.get();
  *p = 10;  

  std::cout << foo.get() << ":" << *foo << "\n";
  std::cout << p << ":" << *p << "\n";
  return 0;
}

/*
output:
    0000023D045A6010:10
    0000023D045A6010:10
*/
get_deleter

返回对象存储的删除器。

      deleter_type& get_deleter() noexcept;
const deleter_type& get_deleter() const noexcept;

#include <iostream>
#include <memory>

class myDeleter {
    int m_count;
public:
    myDeleter() :m_count(0){}
    template <typename T>
    void operator()(T* p) { // 重载操作符()
        if (p)
        {
            delete p;
            p = nullptr;
            std::cout << "deleter #" << ++m_count << '\n';
        }
    }
};

int main()
{
    {
        myDeleter del;

        std::unique_ptr<int, myDeleter> one(new int, del); // 值
        std::unique_ptr<int, myDeleter> two(new int, one.get_deleter()); // 值
        std::unique_ptr<int, myDeleter&> three(new int, one.get_deleter()); // 引用
        std::unique_ptr<int, myDeleter&> four(new int, del); // 值
        
        *one = 69;
        std::cout << one.get() << ":" << *one << "\n";
        one.reset(); // count = 1

        *two = 96;
        std::cout << two.get() << ":" << *two << "\n";
        two.reset(); // count = 1

        *three = 36;
        std::cout << three.get() << ":" << *three << "\n";
        three.reset(); // count = 2

        *four = 63;
        std::cout << four.get() << ":" << *four << "\n";
        four.reset(); // count = 1
    }

    std::cin.get();
    return 0;
}

/*
output:
00000208D9216010:69
deleter #1
00000208D9216050:96
deleter #1
00000208D9216090:36
deleter #2
00000208D9215AB0:63
deleter #1
*/
release

释放对象存储的指针和对象所有权，并返回该指针。

pointer release() noexcept;

#include <iostream>
#include <memory>
int main()
{
    std::unique_ptr<int> foo(new int);
    int* p = foo.release();
    *p = 10;
    std::cout << foo.get() << "\n";
    std::cout << p << ":" << *p << "\n";
    delete p; // 注意:foo对象释放所有权后不再自动释放.
    return 0;
}

/*
output:
	0000000000000000
	000002B7B3386010:10
*/
reset

如果p是空，销毁该对象管理的内存；

如果p不是空，销毁该对象管理的内存，并且该对象重新获取p的所有权；

void reset (pointer p = pointer()) noexcept;

#include <iostream>
#include <memory>

int main()
{

    std::unique_ptr<int> foo(new int);
    *foo = 10;
    {
        std::cout << "before foo calls reset:" << foo.get() << " : " << *foo << "\n"; // 有效地址
        foo.reset(); //删除该指针管理的对象
        std::cout << "after foo calls reset:" << foo.get() << "\n"; // 无效地址
        foo.reset(new int); //获取新的指针
        *foo = 11;
        std::cout << "before foo calls reset(p):" << foo.get() << ":" << *foo << "\n"; // 有效地址
    }

    std::cin.get();
    return 0;
}

/*
output:
before foo calls reset:0000020076BF6010 : 10
after foo calls reset:0000000000000000
before foo calls reset(p):0000020076BF6010:11
*/
swap

交互俩个对象的所有权（包括deleter）

void swap (unique_ptr& x) noexcept;

#include <iostream>
#include <memory>

int main()
{
    {
        std::unique_ptr<int> foo(new int);
        std::unique_ptr<int> bar(new int);
        *foo = 66;
        *bar = 99;
        std::cout << "before foo calls swap:" << foo.get() << " : " << *foo << "\n";
        std::cout << "before bar calls swap:" << bar.get() << " : " << *bar << "\n";
         foo.swap(bar);
         std::cout << "after foo calls swap:" << foo.get() << " : " << *foo << "\n";
         std::cout << "after bar calls swap:" << bar.get() << " : " << *bar << "\n";
    }
    std::cin.get();
    return 0;
}

/*
output:
before foo calls swap:0000019734716010 : 66
before bar calls swap:0000019734716050 : 99
after foo calls swap:0000019734716050 : 99
after bar calls swap:0000019734716010 : 66
*/
operator=

获取对象的所有权和删除器(右值将被析构，所有权都转移，就像调用reset()方法一样）。

unique_ptr& operator= (unique_ptr&& x) noexcept; // 移动赋值
unique_ptr& operator= (nullptr_t) noexcept; // 赋值nullptr
template <class U, class E>
  unique_ptr& operator= (unique_ptr<U,E>&& x) noexcept; // 类型转换赋值
unique_ptr& operator= (const unique_ptr&) = delete; // 拷贝赋值

#include <iostream>
#include <memory>

int main()
{
    {
        std::unique_ptr<int> foo;
        std::unique_ptr<int> boo(nullptr); //  赋值nullptr

        foo = std::unique_ptr<int>(new int(96)); // 类型转换赋值
        std::cout << "[foo]" << foo.get() << ':' << *foo << '\n';
        
        boo = std::move(foo); // 移动赋值
        std::cout << "[boo]"  << boo.get() << ':' << *boo << '\n';
    }

    std::cin.get();
    return 0;
}

/*
[foo]00000163BD716010:96
[boo]00000163BD716010:96
*/
operator bool

检测管理对象的指针是否为空（get()!=nullptr）。

explicit operator bool() const noexcept;

#include <iostream>
#include <memory>

int main()
{
    {
        std::unique_ptr<int> foo(new int);
        std::unique_ptr<int> bar;     
        std::cout << "foo is " << (foo ? "not empty!\n" : "empty\n");
        std::cout << "bar is " << (bar ? "not empty!\n" : "empty\n");
    }
    std::cin.get();
    return 0;
}
/*
output:
foo is not empty!
bar is empty
*/

练习

#include <iostream>
#include <memory>

using namespace std;

class TestPtr {
public:
    TestPtr() :name("default")
    {
        std::cout << __func__ << " : " << name << "\n";
    }
    TestPtr(const char *_name) :name(_name)
    {
        std::cout << __func__ << " : " << name << "\n";
    }
    ~TestPtr()
    {
        std::cout << __func__ << " : " << name << "\n";
    }

    void PrintName(void)
    {
        std::cout << "Name:"  << name << "\n";
    }
private:
    std::string name;
};

void Test()
{
    TestPtr* p4(nullptr);
    int i = 1;
    {
        std::unique_ptr<TestPtr> p3(new TestPtr("p3"));

        {
            std::unique_ptr<TestPtr> p0(new TestPtr("p0")); // 方式一
            std::cout << '[' << i++ << "] p0:" << p0.get() << "\n";
            std::unique_ptr<TestPtr> p1 = std::move(p0); // 移动p0的对象到p1, 内存不释放
            std::cout << '[' << i++ << "] after p0 calls move    :" << p0.get() << "\n"; // 无效地址:唯一指针，转移后为本身指向nullptr
            std::cout << '[' << i++ << "] after p0 is moved to p1:" << p1.get() << "\n"; // 有效地址:指向p0原来指向的地址
            p1.reset(); // 主动释放p1的内存
            std::cout << '[' << i++ << "] after reset p1:" << p1.get() << "\n"; // 无效地址:主动调用析构释放内存

            std::unique_ptr<TestPtr> p2 = std::make_unique<TestPtr>("p2"); // 方式二
            std::cout << '[' << i++ << "] p2:" << p2.get() << "\n";

            p4 = p3.release(); // 释放p3对象存储内存所有权,返回给p4
            p3 = std::move(p2); // 移动p2的对象到p3, 对象的内存不释放,p3的对象内存自动释放
            std::cout << '[' << i++ << "] after p2 calls move    :" << p2.get() << "\n"; // 无效地址:唯一指针，转移后为本身指向nullptr
            std::cout << '[' << i++ << "] after p2 is moved to p3:" << p3.get() << "\n"; //  有效地址:指向p2原来指向的地址
        } // p3 内存不释放

        p3->PrintName(); // name:p2

        p4->PrintName(); // name: p3
    } // 离开作用域后析构函数自动释放 p3的内存

    if (p4)
    {
        std::cout << "p4 is not empty ptr, need manual delete it!\n";
        delete p4; // 手动释放p3对象的内存,不释放就内存泄露
        p4 = nullptr;
    }
    else
    {
        std::cout << "p4 is empty ptr,good!\n";
    }
}


int main()
{
    Test();
    std::cin.get();
    return 0;
}
/*
output:
TestPtr : p3
TestPtr : p0
[1] p0:0000014A1968D580
[2] after p0 calls move    :0000000000000000
[3] after p0 is moved to p1:0000014A1968D580
~TestPtr : p0
[4] after reset p1:0000000000000000
TestPtr : p2
[5] p2:0000014A1968D580
[6] after p2 calls move    :0000000000000000
[7] after p2 is moved to p3:0000014A1968D580
Name:p2
Name:p3
~TestPtr : p2
p4 is not empty ptr, need manual delete it!
~TestPtr : p3
*/
Ro00okie
关注
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++11 新特性 ⑥ | 智能指针 unique_ptr、shared_ptr 和 weak_ptr
dvlinker的技术专栏
09-10 2万+
详细讲解C++11中的智能指针 unique_ptr、shared_ptr 和 weak_ptr。
[C++]智能指针unique_ptr,shared_ptr,weak_ptr
FightFightFight的博客
12-25 1454
C++中对于动态内存的使用非常严格，一次申请必须对应一次释放，否则将造成内存泄漏。这也要求程序员格外小心，比如如下示例: void getStr() { std::string * pstr = new std::string();//pstr为局部变量 *pstr = "Hello world"; .... return; } 当该方法执行完毕后，局部变量pst...
C++11之 unique_ptr
绝知此事要躬行
08-24 3889
原文地址为：http://www.drdobbs.com/cpp/c11-uniqueptr/240002708 在C++11中加入了很多的新特性，unique_ptr一枝独秀，对于动态分配的内存对象，它简单有效。虽然它不是万能的，但是它做的已经够好了：利用简单的语法便可以管理动态分配的对象。 基本语法： unique_ptr 是一个模板类，你可以很简单地构造一个unique_ptr
C++ 智能指针 unique_ptr
最新发布
qq_50373827的博客
09-21 1308
unique_ptr支持自定义删除器，以处理非默认的对象销毁行为。例如，管理通过fopen打开的文件：");自定义删除器在定义unique_ptr时需要指定删除函数的类型。在使用自定义删除器时，必须确保删除器的类型与unique_ptr定义时一致，否则可能会导致删除行为不正确，甚至内存泄漏。
智能指针(三):unique_ptr使用简介
热门推荐
weiwenhp
03-22 7万+
我们知道auto_ptr通过复制构造或者通过=赋值后,原来的auto_ptr对象就报废了.所有权转移到新的对象中去了.而通过shared_ptr可以让多个智能指针对象同时拥有某一块内存的访问权.但假如我们不希望多个内存块被多个智能指针对象共享,同时又不会像auto_ptr那样不知不觉的就让原来的auto_ptr对象失效,可咋整呢? 这个时候就要使用unique_ptr了,顾名思义嘛,unique
C++智能指针unique_ptr
weixin_44651073的博客
02-26 835
智能指针unique_ptr语法详解
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++11智能指针中的 unique_ptr实例详解
08-19
《C++11智能指针中的unique_ptr实例详解》 C++11引入了智能指针，其中的unique_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++智能指针之unique_ptr（保姆级教学）
qq_25218501的博客
09-07 3028
独占式指针（专属所有权），同一时刻，只能有一个unique_ptr指向这个对象；当指针销毁，指向的对象也销毁；因此该指针不支持拷贝和赋值操作，也不存在引用计数。
智能指针 -- unique_ptr
猿来如此yXy
11-08 894
unique_ptr源码分析 代码示例 默认构造函数，操作符(), 以及get(),操作符-> 示例运行结果： 过程分析:那么该示例实际都调用了unique_ptr这个类中的哪些接口呢 ？默认构造函数上述语句会调用unique_ptr的默认构造函数: template
c++智能指针（3） -- unique_ptr
weixin_68026222的博客
04-15 1588
unique_ptr p1(new 空间);// 类型: 智能指针指向的类型，空间：智能指针管理的空间// 创建一个p1的智能指针对象，其指向int类型的数据，动态开辟一个int类型的空间作为参数(其内部的指针会指向这片空间)// 创建一个空对象，指向int类型的数据，其内部的指针会指向NULL// 临时对象// 注意：这样会导致两个指针指向一片空间(我们尽量不要这么做)
C++智能指针unique_ptr 详解
sinat_31608641的博客
07-29 8825
一、智能指针 C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。 二、unique_ptr 简介 unique_ptr 是从 C++ 11 开始，定义在 <memory> 中的智能指针(smart pointer)。它持有对对象的独有权，即两个 unique_ptr 不能指向一个对象，不能进行复制操作只能进行移动操作。 unique_ptr 之所以叫这个名字，是因为它智能指向一个对象，即当它指向其
c++智能指针---unique_ptr
qq_44778436的博客
03-28 507
c++智能指针---unique_ptr
C++智能指针——unique_ptr
weixin_43945471的博客
03-17 181
C++智能指针——unique_ptr
C++：智能指针 [unique_ptr]
EastWood2013的个人空间
07-21 823
int x;int y;int x;int y;} };return 0;(10, 20);return 0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值