C++内存管理之shared_ptr

逃离我推掉我的手 2022-12-22 08:36 60阅读 0赞

**引子**

c++中动态内存的管理是通过new和delete来完成的，只要保证new和delete的配对使用，是没有问题的。但是有时候我们会忘记释放内存，甚至有时候我们根本就不知道什么时候释放内存。特别是在多个线程间共享数据时，更难判断内存该何时释放。这种情况下就机器容易产生引用非法内存的指针。

**In C++, dynamic memory is managed through a pair of operators: new, which allocates, and optionally initializes, an object in dynamic memory and returns a pointer to that object; and delete, which takes a pointer to a dynamic object, destroys that object, and frees the associated memory.**  
     **Dynamic memory is problematic because it is surprisingly hard to ensure that we free memory at the right time. Either we forget to free the memory—in which case we have a memory leak—or we free the memory when there are still pointers referring to that memory—in which case we have a pointer that refers to memory that is no longer valid.**

为了更容易（同时也更安全的管）的使用动态内存，新的标准库（C++11）提供了两种智能指针（smart pointer）类型来管理动态对象。智能指针的行为类似于常规指针。重要的区别是它负责自动释放所指向的对象。新标准提供的这两种智能指针的区别在于管理底层指针的方式：**shared\_ptr允许多个指针指向同一个对象；unique\_ptr则独占所指向的对象**。标准库还定义了一个weak\_ptr的伴随类，他是一种弱引用，指向shared\_ptr所管理的对象。这三种类型都定义在memory头文件中。

**To make using dynamic memory easier (and safer), the new library provides two smart pointer types that manage dynamic objects. A smart pointer acts like a regular pointer with the important exception that it automatically deletes the object to which it points. The new library defines two kinds of smart pointers that differ in how they manage their underlying pointers: shared\_ptr, which allows multiple pointers to refer to the same object, and unique\_ptr, which “owns” the object to which it points. The library also defines a companion class named weak\_ptr that is a weak reference to an object managed by a shared\_ptr. All three are defined in the memory header**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Fpbmd6aHV5dXhpYW4_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Fpbmd6aHV5dXhpYW4_size_16_color_FFFFFF_t_70 1][]

![20201118160637876.png][]

** 初始化 sahred\_ptr**

智能指针的使用方式与普通指针类似。解引用一个智能指针返回它指向的对象。如果在一个条件判断中使用智能指针，效果就是检测它是否为空：

We use a smart pointer in ways that are similar to using a pointer. Dereferencing a smart pointer returns the object to which the pointer points. **When we use a smart pointer in a condition, the effect is to test whether the pointer is null:**

#include <iostream>
    
    using namespace std;
    
    int main()
    {　　
    　　/*---------空指针------------*/
    　　 shared_ptr<string> p1;
        if(!p1)                     　　　　//!默认初始化的智能指针中保存着一个空指针！并不是""空字符串
            cout<<"p1==NULL"<<endl;
    
    　　/*---------初始化------------*/
    　　shared_ptr<string> p2(new string); 
    　　if(p2&&p2->empty()){ 　　　　　　　　//！需要注意的是empty是属于string的成员函数。 
    　　　　*p2="helloworld"; 
    　　　　cout<<*p2<<endl;
    　　}
    //    shared_ptr<int> pa = new int(1);//！error:不允许以暴露裸漏的指针进行赋值操作。
    
    　　//一般的初始化方式
        shared_ptr<string> pint(new string("normal usage!"));
        cout<<*pint<<endl;
    
        //推荐的安全的初始化方式
        shared_ptr<string> pint1 = make_shared<string>("safe uage!");
        cout<<*pint1<<endl;
    }

** 关于mak\_shared函数：**

最安全的分配和使用动态内存的方法是调用一个名为make\_shared的标准库函数，此函数在动态内存中分配一个对象并初始化它，返回此对象的shared\_ptr。与只能指针一样，make\_shared也定义在头文件memory中。

The make\_shared Function

**The safest way to allocate and use dynamic memory is to call a library function named make\_shared. This function allocates and initializes an object in dynamic memory and returns a shared\_ptr that points to that object. Like the smart pointers, make\_shared is defined in the memory header. When we call make\_shared, we must specify the type of object we want to create. We do so in the same way as we use a template class, by following the function name with a type enclosed in angle brackets:**

#include <iostream>
    using namespace std;
    
    int main()
    {
        shared_ptr<int> p3 = make_shared<int>(42);
        cout<<*p3<<endl;
    
        shared_ptr<string> pstr = make_shared<string>("99999");
        cout<<*pstr<<endl;
    
        shared_ptr<int> pint = make_shared<int>(); //!默认初始化为 0
        cout<<*pint<<endl;
    
        auto pau = make_shared<string>("auto");    //!更简单，更常用的方式。
        cout<<*pau<<endl;
    }

**关于其它初始化智能指针的方法，如下；不推荐！在这里展示出来是希望极力避免不安全的使用范例。**

/*不推荐*/
        int * p = new int(32);
        shared_ptr<int> pp(p);
        cout<<*pp<<endl;
    
        /*意外的情况*/
    //    delete p;               //!不小心把delete掉了。
    //    cout<<*pp<<endl;·       //!pp也不再有效。

**shared\_ptr的拷贝和赋值**

**Copying and Assigning shared\_ptrs**

**　　**当进行拷贝或者赋值操作时，每个shared\_ptr都会记录有多少个其他的shared\_ptr指向相同的对象：

> **When we copy or assign a** **shared\_ptr****, each shared\_ptr keeps track of how many other shared\_ptrs point to the same object:**

**引用计数：**

可以认为每个shared\_ptr都有一个关联的计数器，通常称其为**引用计数。**无论何时我们拷贝一个shared\_ptr，计数器都会递增。例如，当用一个shared\_ptr去初始化另一个shared\_ptr；当我们给shared\_ptr赋予一个新的值或者是shared\_ptr被销毁(例如一个局部的shared\_ptr离开其作用域)时，计数器就会递减。一旦一个shared\_ptr的计数器变为0，他就会自动释放自己所管理的对象。

> We can think of a **shared\_ptr** as if it has an **associated** counter, usually referred to as a reference count.**Whenever we copy a shared\_ptr, the count is incremented.** For example, the counter associated with a shared\_ptr is incremented when we use it to initialize another shared\_ptr, when we use it as the right-hand operand of an assignment, or when we pass it to (§ 6.2.1, p. 209) or return it from a function by value (§ 6.3.2, p. 224). The counter is decremented when we assign a new value to the shared\_ptr and when the shared\_ptr itself is destroyed, such as when a local shared\_ptr goes out of scope (§ 6.1.1, p. 204).  
>

auto p = make_shared<int>(42); // object to which p points has one user
    auto q(p); // p and q point to the same object
    // object to which p and q point has two users

#include <iostream>
    using namespace std;
    
    int main()
    {
        auto p = make_shared<int>(42); //!p指向的对象只有p一个引用者。
        cout<<p.use_count()<<endl;
        auto q(p);                     //!p和q指向相同的对象，此对象有两个引用者。
        cout<<p.use_count()<<endl;
        return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Fpbmd6aHV5dXhpYW4_size_16_color_FFFFFF_t_70]: /images/20221120/98b6cdfc76a44bdb80b18e332890468f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Fpbmd6aHV5dXhpYW4_size_16_color_FFFFFF_t_70 1]: /images/20221120/b081a61a4fa4407e9c55c1f6ba3400ce.png
[20201118160637876.png]: https://img-blog.csdnimg.cn/20201118160637876.png