c++ 之四大智能指针 std::auto_ptr std::shared_ptr std::unuque std::weak_ptr 比较总结

╰半橙微兮° 2022-04-12 02:56 92阅读 0赞

### 1. 动态内存必要性 ###

程序不知道自己需要多少对象；   
程序不知道对象的准确类型；   
程序需要在多个对象之间共享数据；

### 2. 动态内存在哪里 ###

程序有静态内存、栈内存。静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建或销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配，在程序结束时销毁。   
除了静态内存和栈内存，每个程序还拥有一个内存池。这部分内存被称作自由空间或堆。程序用堆来存储动态分配的对象——即，那些在程序运行时分配的对象。动态对象的生存期由程序来控制，也就是说，当动态对象不再使用时，我们的代码必须显式的销毁它们。（c++ primer P400）

### 3. 自由存储区和堆 ###

自由存储是c++中通过new和delete动态分配和释放对象的抽象概念，通过new来申请的内存区域可称为自由存储区   
堆是操作系统维护的一块内存   
虽然c++编译器默认使用堆来实现自由存储。但两者不能等价

### 4. 动态内存与智能指针 ###

我们知道c++需要注意的地方之一就是对内存的管理，动态内存的使用经常会出现内存泄漏，或者产生引用非法内存的指针   
c++11标准库提供了三种智能指针类型来管理动态对象：

智能指针：自动负责释放所指向的对象，实际上它利用了栈的机制，每一个智能指针都是一个模板类，调用智能指针实际上是创建了一个智能指针的对象，对象生命周期到达尽头的时候，会自动调用智能指针的析构函数，在析构函数里，释放掉它管理的内存，从而避免手动delete。

1.  shared\_ptr 允许多个指针指向同一个对象 
2.  unique\_ptr 独占所指向的对象
3.  weak\_ptr  shared\_ptr的弱引用 
4.  auto\_ptr c++98提出 c++11 摒弃 对于特定对象，和unique\_ptr一样只能被一个智能指针所拥有，这样，只有拥有该对象的智能指针的析构函数才会删除该对象

定义在memory头文件中，他们的作用在于会自动释放所指向的对象

### 5. 智能指针的详细描述 ###

### 5.1 auto\_ptr描述 ###

auto\_ptr主要是用来解决资源自动释放的问题，比如如下代码：

void Function()
    {
    Obj*p = new Obj(20);
    ...
    if (error occor)
    throw ... 或者 retrun;
    delete p;
    }

在函数遇到错误之后，一般会抛异常，或者返回，但是这时很可能遗漏之前申请的资源，及时是很有经验的程序员也有可能出现这种错误.  
而使用auto\_ptr会在自己的析够函数中进行资源释放。也就是所说的RAII  
使用auto\_ptr代码如下

void Function()
    {
    auto_ptr<Obj> ptr( new Obj(20) );
    ...
    if (error occur)
    throw exception...
    }

这样无论函数是否发生异常，在何处返回，资源都会自动释放。  
需要提一下的是这是一个被c++11标准废弃的一个智能指针，为什么会被废弃，先看一下下面的代码：

auto_ptr<Obj> ptr1( new Obj() );
    ptr1->FuncA();
    auto_ptr<Obj> ptr2 = ptr1;
    ptr2->FuncA();
    ptr1->FuncA();  // 这句话会异常

为什么在把ptr1复制给ptr2之后ptr1再使用就异常了呢？  
这也正是他被抛弃的主要原因。  
因为auto\_ptr复制构造函数中把真是引用的内存指针进行的转移，也就是从ptr1转移给了ptr2,此时，ptr2引用了Obj内存地址，而ptr1引用的内存地址为空，此时再使用ptr1就异常了。

### **5.2 shared\_ptr描述(in memory):** ###

shared\_ptr是一个标准的共享所有权的智能指针，就是允许多个指针指向同一对象，shared\_ptr对象中不仅有一个指针指向某某(比如 int型,以下也拿int类型举例)对象，还拥有一个引用计数器，代表一共有多少指针指向了那个对象。

为什么shared\_ptr允许多个指针指向同一对象?  
因为 动态对象的所有权不确定。对象可以在多个作用域中共享，又不能像栈对象一样自由地值拷贝。只要有一个对象\\作用域还持有这个动态对象，他就不能销毁，当他没有用时，自动销毁。

### shared\_ptr自动销毁所管理的对象 ###

每当创建一个shared\_ptr的对象指向int型数据，则引用计数器值+1，每当销毁一个shared\_ptr对象，则-1.当引用计数器数据为0时，shared\_ptr的析构函数会销毁int型对象，并释放它占用的内存。

### shared\_ptr和new的配合使用 ###

接受指针作为参数的智能指针的构造函数是explicit类型，意味着**必须使用直接初始化**，不能做隐式类型转换

shared_ptr<int> p1;
    //被初始化成为一个空指针
    
    shared_ptr<int> p2 (new int(4));
    //指向一个值是4的int类型数据
    
    shared_ptr<int> p3 = new int(4);
    //错误，必须直接初始化

shared_ptr<int> Fun(int p) 
    {
        return new int(p); //error
        return shared_ptr<int>(new int(p)); //right
    }

###    不能混合使用普通指针和智能指针，因为智能指针不是单纯的赤裸裸的指针 ###

void process(shared_ptr<int> ptr){
    //受到参数值传递的影响，ptr被构造并且诞生，执行完函数块后被释放
    }
    
    int *x(new int (43));
    //x是一个普通的指针
    
    process(x);
    //错误,int * 不能转换成shared_ptr<int>类型
    
    process(shared_ptr<int> x);
    //临时创造了x,引用数+1，执行完process之后，引用数-1
    
    int j = *x;
    //x是一个空悬指针，是未定义的

###    不能使用get()函数对智能指针赋值或初始化 ###

原因：get()函数得到的是共享对象的地址，是内置指针，指向智能指针管理的对象，而智能指针不仅仅包含地址，两个东西不是一个类型的，也不能彼此包含，因此不能这样做。   
同样，把get（）返回值 绑定到智能指针上也是错误的   
如下：

shared_ptr<int> p (new int(22));
    int *q = p.get();
    //语义没问题
    
    {
    shared_ptr<int> (q);
    //意味着q被绑定，！！！！引用计数器还是1！！！！
    //如果这个被执行，程序块结束以后q和q所指的内容被销毁，则代表着以后执行(*p)的解引用操作，就成了未定义的了。
    }
    
    int r = *p;
    //已经不对了，因为p指向的内存已经在刚才那个代码块里被q释放了

### shared\_ptr的一些操作 ###

shared_ptr<T> p;
    //空智能指针，可指向类型是T的对象
    
    if(p)
     //如果p指向一个对象,则是true
    
    (*p)
    //解引用获取指针所指向的对象
    
    p -> number == (*p).number;
    
    p.get();
    //返回p中保存的指针
    
    swap(p,q);
    //交换p q指针
    
    p.swap(q);
    //交换p,q指针
    
    make_shared<T>(args) 
    //返回一个shared_ptr的对象，指向一个动态类型分配为T的对象，用args初始化这个T对象
    
    shared_ptr<T> p(q)
    //p 是q的拷贝，q的计数器++，这个的使用前提是q的类型能够转化成是T*
    
    shared_pts<T> p(q,d) 
    //p是q的拷贝,p将用可调用对象d代替delete
    //上面这个我其实没懂，也没有查出来这个的意思
    
    p =q;
    //p的引用计数-1，q的+1,p为零释放所管理的内存
    
    p.unique();
    //判断引用计数是否是1，是，返回true
    
    p.use_count();
    //返回和p共享对象的智能指针数量
    
    p.reset();
    p.reset(q);
    p.reset(q,d);
    //reset()没懂，这个以后再来补充吧

### shared\_ptr 强引用和弱引用 ###

强引用和弱引用就是shared\_ptr用来维护引用计数的信息

*  强引用

用来记录当前有多少个存活的 shared\_ptrs 正持有该对象. 共享的对象会在最后一个强引用离开的时候销毁( 也可能释放).

*  弱引用

用来记录当前有多少个正在观察该对象的 weak\_ptrs. 当最后一个弱引用离开的时候, 共享的内部信息控制块会被销毁和释放 (共享的对象也会被释放, 如果还没有释放的话).

*  当进行拷贝或赋值操作时，每个shared\_ptr都会记录有多少个其他的shared\_ptr指向相同的对象
 *  当指向一个对象的最后一个shared\_ptr被销毁，shared\_ptr类会自通过调用对应的析构函数销毁此对象　　
 *  shared\_ptr会自动释放相关联的内存

//该函数返回一个T类型的动态分配的对象，对象是通过一个类型为Q的参数来进行初始化的
    shared_ptr<T> Fun(Q arg) 
    {
        //对arg进行处理
        //shared_ptr负责释放内存
        return make_shared<T>(arg);
        //由于返回的是shared_ptr，我们可以保证他分配的对象会在恰当的时候释放
    }
    
    void use_Fun(Q arg) 
    {
        shared_ptr<T> p = Fun(arg);
        //使用p
    }
    //函数结束，p离开了作用域，他指向的内存被自动释放
    
    shared_ptr<T> use_Fun(Q arg) 
    {
        shared_ptr<T> p = Fun(arg);
        //使用p
        return p; //返回p时，引用计数递增
    }
    //p离开了作用域，但他不会释放指向的内存

### shared\_ptr 测试例子 ###

#define _CRT_SECURE_NO_WARNINGS
    
    #include <iostream>
    #include <string>
    #include <memory>
    #include <vector>
    #include <map>
    
    
    void mytest()
    {
        std::shared_ptr<int> sp1(new int(22));
        std::shared_ptr<int> sp2 = sp1;
        std::cout << "cout: " << sp2.use_count() << std::endl; // 打印引用计数
    
        std::cout << *sp1 << std::endl;
        std::cout << *sp2 << std::endl;
    
        sp1.reset(); // 显示让引用计数减一
        std::cout << "count: " << sp2.use_count() << std::endl; // 打印引用计数
    
        std::cout << *sp2 << std::endl; // 22
    
        return;
    }
    
    int main()
    {
        mytest();
    
        system("pause");
        return 0;
    }

###    5.3 unique\_ptr描述(in memory): ###

unique\_ptr的直观认知应该就是“独占”、“拥有”,与shared\_ptr不同，某一时刻，只能有一个unique\_ptr指向一个给定的对象**即不能拷贝和赋值**。因此，当unique\_ptr被销毁,它所指的对象也会被销毁。

unique\_ptr的“独占”是指：不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique\_ptr赋值给另一个unique\_ptr。例如：

std::unique_ptr<int> p (new int);
    std::unique_ptr<int> q = p; //error

但是unique\_ptr允许通过函数返回给其他的unique\_ptr，还可以通过std::move来转移到其他的unique\_ptr，注意，这时它本身就不再拥有原来指针的所有权了。后面都会提到

### unique\_ptr的初始化必须采用直接初始化 ###

unique_ptr<string> p(new string("China"));
    //没问题
    
    unique_ptr<string> p (q);
    //错误，不支持拷贝
    
    unique_ptr<string> q;
    
    q = p;
    //错误,不支持赋值
    
    unique_ptr的一些操作:
    unique_ptr<T> p;
    //空智能指针，可指向类型是T的对象
    
    if(p) 
    //如果p指向一个对象,则是true
    
    (*p)
    //解引用获取指针所指向的对象
    
    p -> number == (*p).number;
    
    p.get();
    //返回p中保存的指针
    
    swap(p,q);
    //交换p q指针
    
    p.swap(q);
    //交换p,q指针
    
    unique_ptr<T,D>p;
    //p使用D类型的可调用对象释放它的指针
    
    p = nullptr;
    //释放对象，将p置空
    
    p.release();
    //p放弃对指针的控制，返回指针，p置数空
    
    p.reset();
    //释放p指向的对象
    
    p.reset(q);
    //让u指向内置指针q

### **unique\_ptr作为参数传递和返回值,是可以拷贝或者赋值的** ###

unique\_ptr的不能拷贝有一个例外：

unique_ptr<int> Fun(int p) 
    {
        return unique_ptr<int>(new int(p));
    }
    //返回一个局部对象的拷贝
    unique_ptr<int> Fun(int p) 
    {
        unique_ptr<int> ret(new int(p));
        //...
        return ret;
    }

编译器知道要返回的对象将要被销毁，执行了一种特殊而“拷贝”（移动操作）

### 如何安全的重用unique\_ptr指针 ###

要安全的重用unique\_ptr指针，可给它赋新值。C++为其提供了std::move()方法。

unique_ptr<string> pu1(new string("nihao"));
        unique_ptr<string> pu2;
        pu2 = std::move(pu1);//move
        cout<<*pu1<<endl;//赋新值

比较而言auto\_ptr由于策略没有unique\_ptr严格，无需使用move方法

auto_ptr<string> pu1, pu2;
        pu1 = demo2("Uniquely special");
        pu2 = pu1;
        pu1 = demo2(" and more");
        cout<<*pu2<<*pu1<<endl;

由于unique\_ptr使用了C++11新增的移动构造函数和右值引用，所以可以区分安全和不安全的用法。

### unique\_ptr相较auto\_ptr提供了可用于数组的变体 ###

auto\_ptr和shared\_ptr可以和new一起使用，但不可以和new\[\]一起使用，但是unique\_ptr可以和new\[\]一起使用

unique_ptr<double[]> pda(new double(5));
    pda.release();
    //自动用delete[]销毁其指针释放内存

### unique\_ptr 测试例子 ###

#define _CRT_SECURE_NO_WARNINGS
    
    #include <iostream>
    #include <string>
    #include <memory>
    #include <vector>
    #include <map>
    
    
    void mytest()
    {
        std::unique_ptr<int> up1(new int(11));   // 无法复制的unique_ptr
        //unique_ptr<int> up2 = up1;        // err, 不能通过编译
        std::cout << *up1 << std::endl;   // 11
    
        std::unique_ptr<int> up3 = std::move(up1);    // 现在p3是数据的唯一的unique_ptr
    
        std::cout << *up3 << std::endl;   // 11
        //std::cout << *up1 << std::endl;   // err, 运行时错误
        up3.reset();            // 显式释放内存
        up1.reset();            // 不会导致运行时错误
        //std::cout << *up3 << std::endl;   // err, 运行时错误
    
        std::unique_ptr<int> up4(new int(22));   // 无法复制的unique_ptr
        up4.reset(new int(44)); //"绑定"动态对象
        std::cout << *up4 << std::endl; // 44
    
        up4 = nullptr;//显式销毁所指对象，同时智能指针变为空指针。与up4.reset()等价
    
        std::unique_ptr<int> up5(new int(55));
        int *p = up5.release(); //只是释放控制权，不会释放内存
        std::cout << *p << std::endl;
        //cout << *up5 << endl; // err, 运行时错误
        delete p; //释放堆区资源
    
        return;
    }
    
    int main()
    {
        mytest();
    
        system("pause");
        return 0;
    }

### 5.4 weak\_ptr描述(in memory) ###

weak\_ptr是一种不控制所指向对象生存期的智能指针，指向shared\_ptr管理的对象，但是不影响shared\_ptr的引用计数。它像shared\_ptr的助手，一旦最后一个shared\_ptr被销毁,对象就被释放，weak\_ptr不影响这个过程。

*  weak\_ptr是为配合shared\_ptr而引入的一种智能指针来协助shared\_ptr工作，它可以从一个shared\_ptr或另一个weak\_ptr对象构造，它的构造和析构不会引起引用计数的增加或减少。没有重载 \* 和 -> 但我们可以通过lock来获得一个shared\_ptr对象来对资源进行使用，如果引用的资源已经释放，lock()函数将返回一个存储空指针的shared\_ptr。 expired函数用来判断资源是否失效。
 *  weak\_ptr的使用更为复杂一点，它可以指向shared\_ptr指针指向的对象内存，却并不拥有该内存，而使用weak\_ptr成员lock，则可返回其指向内存的一个share\_ptr对象，且在所指对象内存已经无效时，返回指针空值nullptr。

注意：weak\_ptr并不拥有资源的所有权，所以不能直接使用资源。  
可以从一个weak\_ptr构造一个shared\_ptr以取得共享资源的所有权。

### weak\_ptr的一些操作: ###

weak_ptr<T> w(sp);
    //定义一个和shared_ptr sp指向相同对象的weak_ptr w,T必须能转化成sp指向的类型
    
    w = p;
    //p是shared_ptr或者weak_ptr，w和p共享对象
    
    w.reset();
    //w置为空
    
    w.use_count();
    //计算与w共享对象的shared_ptr个数
    
    w.expired();
    //w.use_count()为0，返回true
    
    w.lock();
    //w.expired()为true，返回空shared_ptr,否则返回w指向对象的shared_ptr

### weak\_ptr 测试例子 ###

#define _CRT_SECURE_NO_WARNINGS
    
    #include <iostream>
    #include <string>
    #include <memory>
    #include <vector>
    #include <map>
    
    void check(std::weak_ptr<int> &wp)
    {
        std::shared_ptr<int> sp = wp.lock(); // 转换为shared_ptr<int>
        if (sp != nullptr)
        {
            std::cout << "still: " << *sp << std::endl;
        } 
        else
        {
            std::cout << "still: " << "pointer is invalid" << std::endl;
        }
    }
    
    
    void mytest()
    {
        std::shared_ptr<int> sp1(new int(22));
        std::shared_ptr<int> sp2 = sp1;
        std::weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象
    
        std::cout << "count: " << wp.use_count() << std::endl; // count: 2
        std::cout << *sp1 << std::endl; // 22
        std::cout << *sp2 << std::endl; // 22
        check(wp); // still: 22
        
        sp1.reset();
        std::cout << "count: " << wp.use_count() << std::endl; // count: 1
        std::cout << *sp2 << std::endl; // 22
        check(wp); // still: 22
    
        sp2.reset();
        std::cout << "count: " << wp.use_count() << std::endl; // count: 0
        check(wp); // still: pointer is invalid
    
        return;
    }
    
    int main()
    {
        mytest();
    
        system("pause");
        return 0;
    }

### 6. 如何选择智能指针: ###

#include <iostream>
    #include <memory>
    #include <vector>
    #include <algorithm>
    #include <stdlib.h>
    using namespace std;
    
    unique_ptr<int> make_int(int n)
    {
        return unique_ptr<int> (new int(n));
    }
    
    void show(unique_ptr<int> & pi)     //pass by reference
    {
        cout<< *pi <<' ';
    }
    
    int main()
    {
        vector<unique_ptr<int> > vp(5);
        for(int i = 0; i < vp.size(); ++i)
        {
            vp[i] = make_int(rand() % 1000);//copy temporary unique_ptr
        }
        vp.push_back(make_int(rand() % 1000));//ok because arg is temporary
        for_each(vp.begin(), vp.end(), show);
        unique_ptr<int> pup(make_int(rand() % 1000));
       // shared_ptr<int> spp(pup);//not allowed. pup is lvalue
        shared_ptr<int> spr(make_int(rand() % 1000));
    
        return 0;
    }

总结:

1.  当多个对象指向同一个对象的指针时，应选择shared\_ptr 
2.  用new申请的内存，返回指向这块内存的指针时，选择unique\_ptr就不错 
3.  在满足unique\_ptr要求的条件时，前提是没有不明确的赋值，也可以使用auto\_ptr 
4.  如上述代码所示，unique\_ptr为右值(不准确的说类似无法寻址)时，可以赋给shared\_ptr 
5.  尽量使用unique\_ptr而不要使用auto\_ptr
6.  一般来说shared\_ptr能够满足我们大部分的需求
7.  weak\_ptr可以避免递归的依赖关系

###     参考链接: ###

[https://blog.csdn.net/derkampf/article/details/72654883 ][https_blog.csdn.net_derkampf_article_details_72654883]

[https://blog.csdn.net/weixin\_36888577/article/details/80188414 ][https_blog.csdn.net_weixin_36888577_article_details_80188414]

[https://blog.csdn.net/zhuziyu1157817544/article/details/64927834 ][https_blog.csdn.net_zhuziyu1157817544_article_details_64927834]

[https://blog.csdn.net/zsc\_976529378/article/details/52250597][https_blog.csdn.net_zsc_976529378_article_details_52250597]

[https://www.cnblogs.com/lsgxeva/p/7788061.html][https_www.cnblogs.com_lsgxeva_p_7788061.html]

[https_blog.csdn.net_derkampf_article_details_72654883]: https://blog.csdn.net/derkampf/article/details/72654883%C2%A0
[https_blog.csdn.net_weixin_36888577_article_details_80188414]: https://blog.csdn.net/weixin_36888577/article/details/80188414%C2%A0
[https_blog.csdn.net_zhuziyu1157817544_article_details_64927834]: https://blog.csdn.net/zhuziyu1157817544/article/details/64927834%C2%A0
[https_blog.csdn.net_zsc_976529378_article_details_52250597]: https://blog.csdn.net/zsc_976529378/article/details/52250597
[https_www.cnblogs.com_lsgxeva_p_7788061.html]: https://www.cnblogs.com/lsgxeva/p/7788061.html