• c++ 智能指针 shared_ptr

    C++ 智能指针 shared_ptr 详解与示例_码农小明的博客-CSDN博客_shared_ptr

    一、简介

     

            shared_ptr 是c++11的智能类，可以在任何地方都不使用的时候自动删除和相关指针，从而彻底消除内存泄漏和指针悬空的问题。

      她遵循共享所有权，即不同的shared_ptr 对象可以与相同的指针想关联

    每个shared_ptr对象在内部纸箱两个内存位置：

    1、指向对象的指针

    2、用于控制引用计数数据的指针

     

     

    二、shared_ptr 对象的基本操作

    1、创建

    1.     std::shared_ptr<int> p1(new int());  // 有两个内存，1是存放int 的地址，2 是用来引用计数的内存地址（在哪里引用了） 
    2.     p1.use_count();  // 这个指针别引用了多长次

     2、创建空的shared_ptr对象

        std::shared_ptr<int>  ptr1 = std::make_shared<int>();

    因为带有参数的 shared_ptr 构造函数是 explicit 类型的，所以不能像这样std::shared_ptr p1 = new int();隐式调用它构造函数。创建新的shared_ptr对象的最佳方法是使用std :: make_shared：

    这里可以说一下explicit  的所用：

    explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。

    3、分离关联的原始指针

    使用reset() 函数，但是这里有两种方式reset（）和reset(params);

    不带参数的reset()

    1. p1.reset();  // 引用的计数会减一，如果计数为0 ，那么这个指针就会删除
    2.

    带参数的reset()：

    p1.reset(new int(34)); // 将内部指向新的指针，因此其作用计算将变成1

    使用nullptr重置：

    p1 = nullptr; 

    1. if  1
    2.  
    3. int main()
    4. {
    5.  
    6.   //  std::shared_ptr p1(new int());  // 有两个内存，1是存放int 的地址，2 是用来引用计数的内存地址（在哪里引用了） 
    7.     //p1.use_count();  // 这个指针别引用了多长次
    8.  
    9.  
    10.     // 创建一个空对象
    11.     std::shared_ptr<int> p1 = std::make_shared<int>();
    12.     std::cout << "p1  空 的引用次数  " << p1.use_count() << std::endl;
    13.     *p1 = 3334;
    14.     std::cout << "  p1=  " <<*p1 <//输出3334
    15.     std::cout << "  p1的内存地址  " << p1 << std::endl;  //
    16.  
    17.     // 打印引用个数：1
    18.     std::cout << "p1  的引用次数  " << p1.use_count() << std::endl;
    19.     // 创建第二个对象p2 使其指向同一个指针
    20.     std::shared_ptr<int> p2(p1);
    21.     std::cout << "  p2的内存地址  " << p2 << std::endl;  //
    22.     // 下面两个输出都是：2
    23.     std::cout << "p2 引用次数  = " << p2.use_count() << std::endl;
    24.     std::cout << "p1 引用次数  = " << p1.use_count() << std::endl;
    25.  
    26.  
    27.     // 比较智能指针，p1 等于 p2  ，由于p1  p2 的地址是一样的，所以p1==p2
    28.     if (p1 == p2)
    29.     {
    30.         std::cout << "p1 and p2 are pointing to same pointer\n";
    31.     }
    32.     std::cout << "Reset p1 " << std::endl;
    33.  
    34.     // 无参数调用reset，无关联指针，引用个数为0
    35.     p1.reset();
    36.     std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
    37.  
    38.     // 带参数调用reset，引用个数为1
    39.     p1.reset(new int(11));
    40.     std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
    41.  
    42.     // 把对象重置为NULL，引用计数为0
    43.     p1 = nullptr;
    44.     std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
    45.     if (!p1) {
    46.         std::cout << "p1 is NULL" << std::endl; // 输出
    47.     }
    48.  
    49.  
    50.     return  0;
    51.  
    52. }
    53. # endif

     4、自定义删除器 Deleter

    delete Pointer;

    当 shared_ptr 对象指向数组

    1. // 需要添加自定义删除器的使用方式
    2. std::shared_ptr<int> p3(new int[12]);   // 仅用于演示自定义删除器
    3.  
    4. // 指向数组的智能指针可以使用这种形式
    5. std::shared_ptr<int[]> p3(new int[12]);  // 正确使用方式

    给shared_ptr添加自定义删除器

    1. #if  1   // share_ptr 指针的使用
    2.  
    3. struct A
    4. {
    5.     A()
    6.     {
    7.         std::cout << " A \n";
    8.     }
    9.     ~A()
    10.     {
    11.         std::cout << " ~A \n";
    12.     }
    13. };
    14.  
    15. void deleter(A* a)
    16. {
    17.     std::cout << "A   Deleter\n";
    18.     delete[] a;
    19. }
    20.  
    21.  
    22. int main()
    23. {
    24.     std::shared_ptrp4(new A[3], deleter);
    25.  
    26.  
    27.     std::cout << "--------------------------------------------------------\n";
    28.  
    29.   //  std::shared_ptr p1(new int());  // 有两个内存，1是存放int 的地址，2 是用来引用计数的内存地址（在哪里引用了） 
    30.     //p1.use_count();  // 这个指针别引用了多长次
    31.  
    32.  
    33.     // 创建一个空对象
    34.     std::shared_ptr<int> p1 = std::make_shared<int>();
    35.     std::cout << "p1  空 的引用次数  " << p1.use_count() << std::endl;
    36.     *p1 = 3334;
    37.     std::cout << "  p1=  " <<*p1 <//输出3334
    38.     std::cout << "  p1的内存地址  " << p1 << std::endl;  //
    39.  
    40.     // 打印引用个数：1
    41.     std::cout << "p1  的引用次数  " << p1.use_count() << std::endl;
    42.     // 创建第二个对象p2 使其指向同一个指针
    43.     std::shared_ptr<int> p2(p1);
    44.     std::cout << "  p2的内存地址  " << p2 << std::endl;  //
    45.     // 下面两个输出都是：2
    46.     std::cout << "p2 引用次数  = " << p2.use_count() << std::endl;
    47.     std::cout << "p1 引用次数  = " << p1.use_count() << std::endl;
    48.  
    49.  
    50.     // 比较智能指针，p1 等于 p2  ，由于p1  p2 的地址是一样的，所以p1==p2
    51.     if (p1 == p2)
    52.     {
    53.         std::cout << "p1 and p2 are pointing to same pointer\n";
    54.     }
    55.     std::cout << "Reset p1 " << std::endl;
    56.  
    57.     // 无参数调用reset，无关联指针，引用个数为0
    58.     p1.reset();
    59.     std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
    60.  
    61.     // 带参数调用reset，引用个数为1
    62.     p1.reset(new int(11));
    63.     std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
    64.  
    65.     // 把对象重置为NULL，引用计数为0
    66.     p1 = nullptr;
    67.     std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
    68.     if (!p1) {
    69.         std::cout << "p1 is NULL" << std::endl; // 输出
    70.     }
    71.  
    72.  
    73.     return  0;
    74.  
    75. }
    76. # endif

     三、shared_ptr 相对于普通指针的优缺点

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

    与普通指针相比，shared_ptr仅提供-> 、*和==运算符，没有+、-、++、--、[]等运算符。

    NULL检测

    当我们创建 shared_ptr 对象而不分配任何值时，它就是空的；普通指针不分配空间的时候相当于一个野指针，指向垃圾空间，且无法判断指向的是否是有用数据。

    创建 shared_ptr 时注意事项


    不要使用同一个原始指针构造 shared_ptr
    创建多个 shared_ptr 的正常方法是使用一个已存在的shared_ptr 进行创建，而不是使用同一个原始指针进行创建。
    示例：

    1.     int *num = new int(23);
    2.     std::shared_ptr<int> p1(num);
    3.     
    4.     std::shared_ptr<int> p2(p1);  // 正确使用方法
    5.     std::shared_ptr<int> p3(num); // 不推荐
    6.  
    7.     std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 输出 2
    8.     std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 输出 2
    9.     std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 输出 1


    假如使用原始指针num创建了p1，又同样方法创建了p3，当p1超出作用域时会调用delete释放num内存，此时num成了悬空指针，当p3超出作用域再次delete的时候就可能会出错。

    不要用栈中的指针构造 shared_ptr 对象
    shared_ptr 默认的构造函数中使用的是delete来删除关联的指针，所以构造的时候也必须使用new出来的堆空间的指针。
    示例：

    1. int main()
    2. {
    3.    int x = 12;
    4.    std::shared_ptr<int> ptr(&x);
    5.    return 0;
    6. }


    当 shared_ptr 对象超出作用域调用析构函数delete 指针&x时会出错。

    建议使用 make_shared


    为了避免以上两种情形，建议使用make_shared()<>创建 shared_ptr 对象，而不是使用默认构造函数创建。

    1. std::shared_ptr<int> ptr_1 = make_shared<int>();
    2. std::shared_ptr<int> ptr_2 (ptr_1);


    另外不建议使用get()函数获取 shared_ptr 关联的原始指针，因为如果在 shared_ptr 析构之前手动调用了delete函数，同样会导致类似的错误。

    四、智能指针的原理与局限

    Leetcode——C++突击面试_leetcode c++ 面试突破-CSDN博客

    • 共享指针（shared_ptr）：资源可以被多个指针共享，使用计数机制表明资源被几个指针共享。通过 use_count() 查看资源的所有者的个数，可以通过 unique_ptr、weak_ptr 来构造，调用 release() 释放资源的所有权，计数减一，当计数减为 0 时，会自动释放内存空间，从而避免了内存泄漏。

    • 独占指针（unique_ptr）：独享所有权的智能指针，资源只能被一个指针占有，该指针不能拷贝构造和赋值。但可以进行移动构造和移动赋值构造（调用move() 函数），即一个 unique_ptr 对象赋值给另一个 unique_ptr 对象，可以通过该方法进行赋值。

    • 弱指针（weak_ptr）：指向 shared_ptr 指向的对象，能够解决由shared_ptr带来的循环引用问题。

     unique_ptr 怎么赋值给另一个unique_ptr 对象

    使用std::move()  函数将一个对象 全权转移给另一个对象

    1.     std::unique_ptr ptr1Child(new Child());
    2.     std::unique_ptrptrChild2 = std::move(ptr1Child); // 将unique_ptr 指针全部给ptrChild2

     使用智能指针会出现什么问题？怎么解决？

             循环引用

    如上面说，我们使用智能指针的时候 ，按理来说我们的程序在结束的时候，share_ptr 的count=0

    但是我们相互定义使用

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class Child;
    7. class Parent;
    8.  
    9. class Parent {
    10. private:
    11.     shared_ptr ChildPtr;
    12. public:
    13.     void setChild(shared_ptr child) {
    14.         this->ChildPtr = child;
    15.     }
    16.  
    17.     void doSomething() {
    18.         if (this->ChildPtr.use_count()) {
    19.  
    20.         }
    21.     }
    22.  
    23.     ~Parent() {
    24.     }
    25. };
    26.  
    27. class Child {
    28. private:
    29.     shared_ptr ParentPtr;
    30. public:
    31.     void setPartent(shared_ptr parent) {
    32.         this->ParentPtr = parent;
    33.     }
    34.     void doSomething() {
    35.         if (this->ParentPtr.use_count()) {
    36.  
    37.         }
    38.     }
    39.     ~Child() {
    40.     }
    41. };
    42.  
    43. int main() {
    44.     weak_ptr wpp;
    45.     weak_ptr wpc;
    46.     {
    47.         shared_ptr p(new Parent);
    48.         shared_ptr c(new Child);
    49.         p->setChild(c);
    50.         c->setPartent(p);
    51.         wpp = p;
    52.         wpc = c;
    53.         cout << p.use_count() << endl; // 2
    54.         cout << c.use_count() << endl; // 2
    55.     }
    56.     cout << wpp.use_count() << endl;  // 1
    57.     cout << wpc.use_count() << endl;  // 1
    58.     return 0;
    59. }

    循环引用的解决方法： weak_ptr

    循环引用：该被调用的析构函数没有被调用，从而出现了内存泄漏。

    • weak_ptr 对被 shared_ptr 管理的对象存在非拥有性（弱）引用，在访问所引用的对象前必须先转化为 shared_ptr；
    • weak_ptr 用来打断 shared_ptr 所管理对象的循环引用问题，若这种环被孤立（没有指向环中的外部共享指针），shared_ptr 引用计数无法抵达 0，内存被泄露；令环中的指针之一为弱指针可以避免该情况；
    • weak_ptr 用来表达临时所有权的概念，当某个对象只有存在时才需要被访问，而且随时可能被他人删除，可以用 weak_ptr 跟踪该对象；需要获得所有权时将其转化为 shared_ptr，此时如果原来的 shared_ptr 被销毁，则该对象的生命期被延长至这个临时的 shared_ptr 同样被销毁。 
      1. #include 
      2. #include 
      3.  
      4. using namespace std;
      5.  
      6. class Child;
      7. class Parent;
      8.  
      9. class Parent {
      10. private:
      11.     //shared_ptr ChildPtr;
      12.     weak_ptr ChildPtr;
      13. public:
      14.     void setChild(shared_ptr child) {
      15.         this->ChildPtr = child;
      16.     }
      17.  
      18.     void doSomething() {
      19.         //new shared_ptr
      20.         if (this->ChildPtr.lock()) {
      21.  
      22.         }
      23.     }
      24.  
      25.     ~Parent() {
      26.     }
      27. };
      28.  
      29. class Child {
      30. private:
      31.     shared_ptr ParentPtr;
      32. public:
      33.     void setPartent(shared_ptr parent) {
      34.         this->ParentPtr = parent;
      35.     }
      36.     void doSomething() {
      37.         if (this->ParentPtr.use_count()) {
      38.  
      39.         }
      40.     }
      41.     ~Child() {
      42.     }
      43. };
      44.  
      45. int main() {
      46.     weak_ptr wpp;
      47.     weak_ptr wpc;
      48.     {
      49.         shared_ptr p(new Parent);
      50.         shared_ptr c(new Child);
      51.         p->setChild(c);
      52.         c->setPartent(p);
      53.         wpp = p;
      54.         wpc = c;
      55.         cout << p.use_count() << endl; // 2
      56.         cout << c.use_count() << endl; // 1
      57.     }
      58.     cout << wpp.use_count() << endl;  // 0
      59.     cout << wpc.use_count() << endl;  // 0
      60.     return 0;
      61. }

  • 相关阅读:
    gprof 分析程序执行时间和函数调用次数
    PCB电路板去耦电容配置原则有哪些？
    外贸老鸟帮新人点评、修改的5个开发信案例
    Java中的容器(二) 双例集合
    docker基本使用总结
    10月26日，起立&LG新品首发第五代OLED透明显示屏
    快速幂求逆元
    雷达SAR成像仿真的应用（Matlab代码实现）
    企业虚拟网络管理
    实时数据同步工具的真正作用和对应应用场景
  • 原文地址：https://blog.csdn.net/weixin_39354845/article/details/128002798