• C++：详细的说明智能指针的使用以及底层实现，以及删除器和包装器的使用

    1.智能指针

    1.1概念：

    智能指针并非指针，他是一个类对象。这个对象托管了堆区的资源。

     1.2机制：

    当栈上的智能指针对象出栈时，所托管的堆区对象自动进行析构。

    用到的知识点就是栈上对象出栈自动销毁的特性，因为出栈即自动调用析构。

    RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。

    那么到底什么是 RALL 机制？

    使用 C++ 时，最让人头疼的便是内存管理，但却又正是对内存高度的可操作性给了 C++ 程序猿极大的自由与装逼资本。

    当我们 new 出一块内存空间，在使用完之后，如果不使用 delete 来释放这块资源则将导致内存泄露，这在中大型项目中是极具破坏性的。但是人无完人，我们并不能保证每次都记得释放无法再次获取到且不再使用的内存。

    2.auto_ptr资源所有权转移智能指针

    2.1auto_ptr的使用：

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. class Stu
    7. {
    8.     int age;
    9.     string name;
    10. public:
    11.     Stu(string name,int age)
    12.     {
    13.         this->age=age;
    14.         this->name=name;
    15.  
    16.         cout<<"STU的构造"<
    17.     }
    18.  
    19.     ~Stu()
    20.     {
    21.         cout<<"STU的析构"<
    22.     }
    23.  
    24.     void show_info()
    25.     {
    26.         cout<<this->age<<this->name<
    27.     }
    28.  
    29. };
    30.  
    31. int main()
    32. {
    33.     auto_ptr stu(new Stu("lisi",12));
    34.     stu->show_info();
    35.     return 0;
    36. }

    结果图：

     分析：像这样我们即使不手动释放堆区的资源，他也会自动释放。

    2.2auto_ptr的底层实现：

    1. #include 
    2.  
    3. using namespace std;
    4. class Stu
    5. {
    6.     string name;
    7.     int age;
    8. public:
    9.     Stu(string name,int age)
    10.     {
    11.         this->name=name;
    12.         this->age=age;
    13.         cout<<"stu的构造"<
    14.     }
    15.  
    16.     ~Stu()
    17.     {
    18.         cout<<"stu的析构"<
    19.     }
    20.  
    21.     void show_info()
    22.     {
    23.         cout<<this->name<<","<<this->age<
    24.     }
    25. };
    26.  
    27. template <class T>
    28. class Auto_ptr
    29. {
    30.     T* ptr;
    31. public:
    32.     Auto_ptr(T* _ptr)
    33.     {
    34.         this->ptr=_ptr;
    35.     }
    36.  
    37.     ~Auto_ptr()
    38.     {
    39.         delete ptr;
    40.         ptr=NULL;
    41.     }
    42.  
    43.     Auto_ptr(const Auto_ptr& other)
    44.     {
    45.         this->ptr=other.ptr;
    46.         const_cast(other)->ptr=nullptr;
    47.     }
    48.  
    49.     Auto_ptr& operator=(const Auto_ptr& other)
    50.     {
    51.         if(this->ptr!=nullptr){
    52.             delete this->ptr;
    53.             this->ptr=nullptr;
    54.         }
    55.  
    56.         this->ptr=other.ptr;
    57.     }
    58.  
    59.     T* get()
    60.     {
    61.         return this->ptr;
    62.     }
    63.  
    64.     T* operator->()
    65.     {
    66.         return this->ptr;
    67.     }
    68. };
    69.  
    70. int main()
    71. {
    72.  
    73.     Auto_ptr stu(new Stu("lisi",20));
    74.     stu.operator->()->show_info();
    75.     stu->show_info();
    76.  
    77.     return 0;
    78. }

    结果图：

     分析：这就是智能指针auto_ptr的实现。

    2.3auto_ptr的缺点：

    2.3.1通过代码来说明问题：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. class Stu
    6. {
    7.     string name;
    8.     int age;
    9. public:
    10.     Stu(string name,int age)
    11.     {
    12.         this->name=name;
    13.         this->age=age;
    14.         cout<<"stu的构造"<
    15.     }
    16.  
    17.     ~Stu()
    18.     {
    19.         cout<<"stu的析构"<
    20.     }
    21.  
    22.     void show_info()
    23.     {
    24.         cout<<this->name<<","<<this->age<
    25.     }
    26. };
    27.  
    28. template <class T>
    29. class Auto_ptr
    30. {
    31.     T* ptr;
    32. public:
    33.     Auto_ptr(T* _ptr)
    34.     {
    35.         this->ptr=_ptr;
    36.         cout<<"构造"<
    37.     }
    38.  
    39.     ~Auto_ptr()
    40.     {
    41.         delete ptr;
    42.         ptr=NULL;
    43.         cout<<"析构"<
    44.     }
    45.  
    46.     Auto_ptr(const Auto_ptr& other)
    47.     {
    48.         this->ptr=other.ptr;
    49.         const_cast(other)->ptr=nullptr;
    50.     }
    51.  
    52.     Auto_ptr& operator=(const Auto_ptr& other)
    53.     {
    54.         if(this==&other){
    55.             return *this;
    56.          }
    57.  
    58.         if(this->ptr!=nullptr){
    59.             delete this->ptr;
    60.             this->ptr=nullptr;
    61.         }
    62.  
    63.         this->ptr=other.ptr;
    64.     }
    65.  
    66.     T* get()
    67.     {
    68.         return this->ptr;
    69.     }
    70.  
    71.     T* operator->()
    72.     {
    73.         return this->ptr;
    74.     }
    75. };
    76.  
    77. int main()
    78. {
    79.  
    80.  
    81.     Auto_ptr stu(new Stu("zhangsan",20));
    82.     stu->show_info();
    83.     Auto_ptr stu1=stu;
    84.     stu1->show_info();
    85.  
    86.     return 0;
    87. }

    报错图：

    分析：当我们在main函数里面这么写的时候就会出现问题，就是我只要以把数值赋给另外一个，原来的那个就会消失，要是再大型项目中，这肯定会导致很多小问题，而且我们从这个报错也看到了，系统并不让我们删除，也说明了这个问题的严重性，所以这个智能指针被废弃了，当然也还能用哈。

    3.带有引用记数器的共享智能指针shared_ptr（重点）

    3.1shared_ptr的使用方法：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. class Stu
    6. {
    7.     string name;
    8.     int age;
    9. public:
    10.     Stu(string name,int age)
    11.     {
    12.         this->name=name;
    13.         this->age=age;
    14.         cout<<"stu的构造"<
    15.     }
    16.  
    17.     ~Stu()
    18.     {
    19.         cout<<"stu的析构"<
    20.     }
    21.  
    22.     void show_info()
    23.     {
    24.         cout<<this->name<<","<<this->age<
    25.     }
    26. };
    27.  
    28.  
    29.  
    30. int main()
    31. {
    32.  
    33.     shared_ptr stu(new Stu("lisi",23));
    34.     stu->show_info();
    35.     cout<use_count()<
    36.  
    37.     shared_ptr stu1=stu;
    38.     stu1->show_info();
    39.     cout<use_count()<
    40.  
    41.     return 0;
    42. }

    结果图：

     3.2shared_ptr的底层实现：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. using namespace std;
    6. class Stu
    7. {
    8.     string name;
    9.     int age;
    10. public:
    11.     Stu(string name,int age)
    12.     {
    13.         this->name=name;
    14.         this->age=age;
    15.         cout<<"stu的构造"<
    16.     }
    17.  
    18.     ~Stu()
    19.     {
    20.         cout<<"stu的析构"<
    21.     }
    22.  
    23.     void show_info()
    24.     {
    25.         cout<<this->name<<","<<this->age<
    26.     }
    27. };
    28. template <class T>
    29. class Recounts
    30. {
    31.     T* ptr;
    32.     int counts;
    33. public:
    34.     Recounts(T* _ptr=nullptr)
    35.     {
    36.         this->ptr=_ptr;
    37.  
    38.         if(this->ptr!=nullptr){
    39.             this->counts=1;
    40.         }
    41.     }
    42.  
    43.     void my_add()
    44.     {
    45.         ++(this->counts);
    46.     }
    47.  
    48.     int my_sub()
    49.     {
    50.         return  --(this->counts);
    51.     }
    52.  
    53.     int get_counts()
    54.     {
    55.         return this->counts;
    56.     }
    57. };
    58.  
    59. template <class T>
    60. class Shared_ptr
    61. {
    62.     Recounts* recounts;
    63.     T* ptr;
    64. public:
    65.     Shared_ptr(T* _ptr=nullptr)
    66.     {
    67.         this->ptr=_ptr;
    68.         if(this->ptr!=nullptr){
    69.             recounts=new Recounts(ptr);
    70.         }
    71.     }
    72.  
    73.     ~Shared_ptr()
    74.     {
    75.         if(recounts->my_sub()==0){
    76.             delete this->ptr;
    77.             delete recounts;
    78.             this->ptr=nullptr;
    79.             recounts=nullptr;
    80.         }
    81.     }
    82.  
    83.     Shared_ptr(const Shared_ptr& other)
    84.     {
    85.         this->ptr=other.ptr;
    86.         this->recounts=other.recounts;
    87.  
    88.         recounts->my_add();
    89.     }
    90.  
    91.     Shared_ptr& operator=(const Shared_ptr& other)
    92.     {
    93.         if(this==&other){
    94.             return *this;
    95.         }
    96.  
    97.         if(this->ptr!=nullptr){
    98.             delete this->ptr;
    99.             this->ptr=nullptr;
    100.         }
    101.  
    102.         this->ptr=other.ptr;
    103.         this->recounts=other.recounts;
    104.         recounts->my_add();
    105.     }
    106.  
    107.     T* operator->()
    108.     {
    109.         return this->ptr;
    110.     }
    111.  
    112.     int usr_counts()
    113.     {
    114.         return recounts->get_counts();
    115.     }
    116. };
    117.  
    118.  
    119.  
    120. int main()
    121. {
    122.     Shared_ptr stu(new Stu("lisi",20));
    123.     stu->show_info();
    124.     stu.usr_counts();
    125.  
    126.     Shared_ptr stu1=stu;
    127.     stu1->show_info();
    128.     stu1.usr_counts();
    129.  
    130.     return 0;
    131. }

    结果图：

    4.weak_ptr

    4.1概念：

    和shared_ptr搭配着用，防止内存泄漏。

    4.1代码说明：

    4.2.1shared_ptr的缺点：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class B;
    7. class A
    8. {
    9. public:
    10.     shared_ptr ptr_b;
    11.     A()
    12.     {
    13.         cout<<"A的构造"<
    14.     }
    15.  
    16.     ~A()
    17.     {
    18.         cout<<"A的析构"<
    19.     }
    20.  
    21.     void show_info()
    22.     {
    23.         cout<<"mrr ai chi shi"<
    24.     }
    25.  
    26. };
    27.  
    28. class B
    29. {
    30. public:
    31.     shared_ptr ptr_a;
    32.     B()
    33.     {
    34.         cout<<"B的构造"<
    35.     }
    36.  
    37.     ~B()
    38.     {
    39.         cout<<"B的析构"<
    40.     }
    41.  
    42.     void single()
    43.     {
    44.         ptr_a->show_info();
    45.     }
    46.  
    47. };
    48.  
    49. int main()
    50. {
    51.     shared_ptr pa(new A);
    52.     shared_ptr pb(new B);
    53.  
    54.     pa->ptr_b=pb;
    55.     pb->ptr_a=pa;
    56.  
    57.     pb->single();
    58.  
    59.     return 0;
    60. }

    结果图：

     由结果图片我们可以看出来，没有进行析构，这是由于当给pa给与堆区地址的时候，计数器的数字加1，当又进行拷贝赋值的时候，pa->ptr_b又在pa的基础上又加了1，所以pa->ptr->b的计数器的数字为2，又因为他们都共享一块内存pb的计数器数字也为2。

    具体实现图：

    详细的GDI使用说明以及GDI库
    application/x-zip 4星 超过85%的资源 4.60MB
    下载

     这个时候我们就可以引出来我们的weak_ptr和shared_ptr是天然的搭档。

    4.2weak_ptr和shared_ptr的天然搭配代码：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class B;
    7. class A
    8. {
    9. public:
    10.     weak_ptr ptr_b;
    11.     A()
    12.     {
    13.         cout<<"A的构造"<
    14.     }
    15.  
    16.     ~A()
    17.     {
    18.         cout<<"A的析构"<
    19.     }
    20.  
    21.     void show_info()
    22.     {
    23.         cout<<"mrr ai chi shi"<
    24.     }
    25.  
    26. };
    27.  
    28. class B
    29. {
    30. public:
    31.     weak_ptr ptr_a;
    32.     B()
    33.     {
    34.         cout<<"B的构造"<
    35.     }
    36.  
    37.     ~B()
    38.     {
    39.         cout<<"B的析构"<
    40.     }
    41.  
    42.     void single()
    43.     {
    44.         if(ptr_a.lock()==nullptr){
    45.             return;
    46.         }
    47.  
    48.         ptr_a.lock()->show_info();
    49.     }
    50.  
    51. };
    52.  
    53. int main()
    54. {
    55.     shared_ptr pa(new A);
    56.     shared_ptr pb(new B);
    57.  
    58.     pa->ptr_b=pb;
    59.     pb->ptr_a=pa;
    60.  
    61.     pb->single();
    62.  
    63.     return 0;
    64. }

    结果图：

     分析：因为使用weak_ptr后计数器不会加1， 这样就能防止内存泄漏了。

    5.独占智能指针：unique_ptr

    5.1概念：

    独一无二的，唯一的智能指针，他是不共享的，他不想其它的共享对象也操作他的指向的堆区空间，他是唯一一个可操作这个堆区空间的对象。也就是说他的类对象是不可以发生拷贝构造与赋值运算符重载的。

    5.2使用方式：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. class A
    6. {
    7. public:
    8.     A()
    9.     {
    10.         cout<<"A的构造"<
    11.     }
    12.  
    13.     ~A()
    14.     {
    15.         cout<<"A的析构"<
    16.     }
    17.  
    18.     void show_info()
    19.     {
    20.         cout<<"mrr ai chi shi"<
    21.     }
    22.  
    23. };
    24.  
    25.  
    26.  
    27. int main()
    28. {
    29.   unique_ptr a(new A);
    30.   a->show_info();
    31.   
    32.     return 0;
    33. }

    结果图：
     

     这个智能指针修饰的内存只能一个人享用，如图：

     5.3底层实现：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class A
    7. {
    8. public:
    9.     A()
    10.     {
    11.         cout<<"A的构造"<
    12.     }
    13.  
    14.     ~A()
    15.     {
    16.         cout<<"A的析构"<
    17.     }
    18.  
    19.     void show_info()
    20.     {
    21.         cout<<"mrr ai chi shi"<
    22.     }
    23.  
    24. };
    25. template <class T>
    26. class Unique_ptr
    27. {
    28.     T* ptr;
    29. public:
    30.     Unique_ptr(T* _ptr)
    31.     {
    32.         this->ptr=_ptr;
    33.     }
    34.  
    35.     Unique_ptr(const Unique_ptr& other)=delete ;
    36.     Unique_ptr& operator=(const Unique_ptr& other)=delete;
    37.  
    38.     ~Unique_ptr()
    39.     {
    40.         delete this->ptr;
    41.         this->ptr=nullptr;
    42.     }
    43.  
    44.     T* operator->()
    45.     {
    46.         return this->ptr;
    47.     }
    48. };
    49.  
    50.  
    51. int main()
    52. {
    53.    Unique_ptr a(new A);
    54.    a->show_info();
    55.    
    56.     return 0;
    57. }

    6.智能指针与自定义删除器及包装器的使用：

    6.1为什么要定义删除器：

    我们可以看一下上面几根智能指针的实现，都是delete ptr；并不是delete []ptr，如果我们不自定义删除的话，就会导致内存泄漏，如下：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class A
    7. {
    8. public:
    9.    A()
    10.    {
    11.        cout<<"A的构造"<
    12.    }
    13.  
    14.    ~A()
    15.    {
    16.        cout<<"A的析构"<
    17.    }
    18. };
    19.  
    20. int main()
    21. {
    22.    shared_ptr a(new A[5]);
    23.  
    24.     return 0;
    25. }

    结果图：

    WEBLOGIN的安装以及使用
    application/msword 0星 超过10%的资源 32KB
    下载


     

     分析：由图可知，构造了五次，析构了一次，造成了内存泄漏，这就是为什么我们要进行用删除器。

    6.2自定义的删除器（函数对象）：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. template <class T>
    6. class Deleter
    7. {
    8. public:
    9.     void operator()(T* p)
    10.     {
    11.         delete [] p;
    12.     }
    13. };
    14.  
    15.  
    16. class A
    17. {
    18. public:
    19.    A()
    20.    {
    21.        cout<<"A的构造"<
    22.    }
    23.  
    24.    ~A()
    25.    {
    26.        cout<<"A的析构"<
    27.    }
    28. };
    29.  
    30. int main()
    31. {
    32.    shared_ptr a(new A[5],Deleter());
    33.  
    34.     return 0;
    35. }

    结果图：

     

    6.3自定义的删除器（匿名6.4函数对象）：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. template <class T>
    6. class Deleter
    7. {
    8. public:
    9.     void operator()(T* p)
    10.     {
    11.         delete [] p;
    12.     }
    13. };
    14.  
    15.  
    16. class A
    17. {
    18. public:
    19.    A()
    20.    {
    21.        cout<<"A的构造"<
    22.    }
    23.  
    24.    ~A()
    25.    {
    26.        cout<<"A的析构"<
    27.    }
    28. };
    29.  
    30. int main()
    31. {
    32.     shared_ptr a(new A[5],[](A* p){
    33.         delete [] p;
    34.     });
    35.  
    36.     return 0;
    37. }

    结果图：

     6.4智能指针的C++官方提供的释放连续空间的删除器

    注意：每个智能指针删除所放的位置不一定相同，可以自己去查一下c++官方手册。

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. template <class T>
    6. class Deleter
    7. {
    8. public:
    9.     void operator()(T* p)
    10.     {
    11.         delete [] p;
    12.     }
    13. };
    14.  
    15.  
    16. class A
    17. {
    18. public:
    19.    A()
    20.    {
    21.        cout<<"A的构造"<
    22.    }
    23.  
    24.    ~A()
    25.    {
    26.        cout<<"A的析构"<
    27.    }
    28. };
    29.  
    30. int main()
    31. {
    32.     unique_ptr> a(new A[5]);
    33.     //unique_ptr> a(new A[5]);//这个也是可以的
    34.     return 0;
    35. }

    结果图：
     

     6.5包装一个匿名函数对象的类型：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6. template <class T>
    7. class Deleter
    8. {
    9. public:
    10.     void operator()(T* p)
    11.     {
    12.         delete [] p;
    13.     }
    14. };
    15.  
    16.  
    17. class A
    18. {
    19. public:
    20.    A()
    21.    {
    22.        cout<<"A的构造"<
    23.    }
    24.  
    25.    ~A()
    26.    {
    27.        cout<<"A的析构"<
    28.    }
    29. };
    30.  
    31. int main()
    32. {
    33.     unique_ptrvoid (A*)>> a(new A[5],Deleter());
    34.  
    35.     return 0;
    36. }

    6.5.1包装器的使用：可以提升函数的效率，就想变成（）函数一样，效率很高。

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6. template <class T>
    7. class Deleter
    8. {
    9. public:
    10.     void operator()(T* p)
    11.     {
    12.         delete [] p;
    13.     }
    14. };
    15.  
    16.  
    17. class A
    18. {
    19. public:
    20.    A()
    21.    {
    22.        cout<<"A的构造"<
    23.    }
    24.  
    25.    ~A()
    26.    {
    27.        cout<<"A的析构"<
    28.    }
    29. };
    30.  
    31. void show_info()
    32. {
    33.     cout<<"加油"<
    34. }
    35.  
    36. int main()
    37. {
    38.     function<void ()> f=show_info;
    39.     f();
    40.  
    41.     return 0;
    42. }

  • 相关阅读:
    vue @cliick.stop @click.prevent @click.self
    一文带你深入了解JVM性能调优以及对JVM调优的全面总结
    【探索Linux】—— 强大的命令行工具 P.8（进程优先级、环境变量）
    UDS诊断入门
    python3GUI--详细讲解一个QQ音乐组件的制作By:PyQt5（详细介绍、附源代码）
    ROS Turtlebot3多机器人编队导航仿真
    带你走进Cflow （一）
    Node-v14.20.0 Windows下的环境变量配置
    在2024年WWDC大会上,苹果宣布了其全新的“Apple Intelligence”AI功能以及ISO18功能
    如何正确的清理C盘
  • 原文地址：https://blog.csdn.net/a2998658795/article/details/126069592