智能指针(二) shared_ptr 注意点

智能指针(二) shared_ptr 注意点

1 不存在 int * 到 shared_ptr 的隐式类型转换

void proc(shared_ptr<int> ptr)
{
    cout << "ptr.use_count()=" << ptr.use_count() << endl;
    cout << "调用成功" << endl;
    return;
}
  int *p = new int(100);

    // todo  1 不存在 int * 到 shared_ptr<int> 的隐式类型转换
    //  proc(p);

2切勿传递临时引用作为函数参数

void proc(shared_ptr<int> ptr)
{
    cout << "ptr.use_count()=" << ptr.use_count() << endl;
    cout << "调用成功" << endl;
    return;
}
  int *p = new int(100);
proc(std::shared_ptr<int>(p)); // 参数是临时的 shared_ptr,用裸指针显示构造
    //  传递到 proc 函数中的引用计数为 1 ,离开函数体后，引用计数为 0 ， 临时构造的shared_ptr指针所指向的内存(也就是p 指向的内存) 被 回收
   *p =25; //此时操作p将是违法的(已置空)

• 把一个普通裸指针绑定到一个shared_ptr 上之后， 内存管理的责任就交给这个shared_ptr了,这个时候就不应该用裸指针来访问shared_ptr所指向的内存了

修正的做法是

 shared_ptr<int> pi(p);
    proc(pi);
    *pi = 45; // 操作安全
    // 传递到 proc 函数中的引用计数为 2 ,离开函数体后，引用计数为 1 ，pi 指向的对象 不会被回收。

3严禁 用裸指针初始化多个 shared_ptr

• 多个shared_ptr 并不会增加引用计数,内存管理将不会贯通(初始化 shared_ptr,但二者并不指向同一个控制块,引用计数不会累计)，

 int *p = new int(100);
    void func()
    {
        shared_ptr<int> p1(p);
        cout << "p1.use_count()" << p1.use_count() << endl;
        shared_ptr<int> p2(p);
        cout << "p1.use_count()" << p1.use_count() << endl;
        // 当 p1 p2 的生命结束时， 指向的对象将被 释放两次（因为p1和p2引用计数均为1,而且p2 是释放同一块已经释放内存的空间）

        // 应用下面的方式代替
        /*
        shared_ptr<int> p1(new int); // 用匿名裸指针 初始化
        shared_ptr<int> p2(p1); //用p1 初始化 其他 shared_ptr


        */
    }

4谨慎 使用 get 返回的裸指针

• 注意 ：get() 返回的裸指针不能delete,否则会异常

 void func()
    {
        cout << "detail2::func()" << endl;
        shared_ptr<int> pi(new int);
        int *p = pi.get();
        delete p;// error
    }

• 不能将智能指针 绑定到get 返回的指针上

void func2()
    {

        // ?. 类似于把裸指针赋值给了两个shared_ptr
        shared_ptr<int> pi(new int);
        cout << "pi.use_count()" << pi.use_count() << endl;
        int *p = pi.get();
        shared_ptr<int> pi2(p);
        cout << "pi.use_count()" << pi.use_count() << endl;
        cout << "pi2.use_count()" << pi2.use_count() << endl;
    }

5 不要返回类对象指针

• 使用类对象this初始化另一个对象, 引用计数将不会增加

 class TC
    {
    public:
        shared_ptr<TC> get_self_this()
        {
            return shared_ptr<TC>(this);
        }
    };
     void func()
    {
        cout << "detail::func()" << endl;
        shared_ptr<TC> p1(new TC);
        cout << "p1.use_count()" << p1.use_count() << endl;
        shared_ptr<TC> p2 = p1->get_self_this();

        cout << "p1.use_count()" << p1.use_count() << endl;
    }

• 使用 shared_from_this 代替

class TC2 : public enable_shared_from_this<TC2>
    {
    public:
        shared_ptr<TC2> get_self_enable_shared()
        {
            // /这个就是enable_shared_from_this类中的方法，要通过此方法返回智能指针
            return shared_from_this();
        }
    };
    
      void func2()
    {
        cout << "detail2::func2()" << endl;
        shared_ptr<TC2> p1(new TC2);
        cout << "p1.use_count()" << p1.use_count() << endl;
        shared_ptr<TC2> p2 = p1->get_self_enable_shared();

        cout << "p1.use_count()" << p1.use_count() << endl;
    }

6 循环引用问题

 class CB;
    class CA
    {
    public:
        CA() { cout << "CA() called! " << endl; }
        ~CA() { cout << "~CA() called! " << endl; }
        void set_ptr(shared_ptr<CB> &ptr) { m_ptr_b = ptr; }
        void b_use_count() { cout << "b use count : " << m_ptr_b.use_count() << endl; }
        void show() { cout << "this is class CA!" << endl; }

    private:
        shared_ptr<CB> m_ptr_b;
    };

    class CB
    {
    public:
        CB() { cout << "CB() called! " << endl; }
        ~CB() { cout << "~CB() called! " << endl; }
        void set_ptr(shared_ptr<CA> &ptr) { m_ptr_a = ptr; }
        void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
        void show() { cout << "this is class CB!" << endl; }

    private:
        shared_ptr<CA> m_ptr_a;
    };

    void test_refer_to_each_other()
    {
        shared_ptr<CA> ptr_a(new CA());
        shared_ptr<CB> ptr_b(new CB());

        cout << "a use count : " << ptr_a.use_count() << endl;
        cout << "b use count : " << ptr_b.use_count() << endl;

        ptr_a->set_ptr(ptr_b);
        ptr_b->set_ptr(ptr_a);

        cout << "a use count : " << ptr_a.use_count() << endl;
        cout << "b use count : " << ptr_b.use_count() << endl;
    }
    int main()
    {
    test_refer_to_each_other();
    }

CA() called!
CB() called!
a use count : 1
b use count : 1
a use count : 2
b use count : 2

• 通过结果可以看到，最后CA和CB的对象并没有被析构，其中的引用效果如下图所示，起初定义完ptr_a和ptr_b时，只有 ptr_a 指向new_CA（） 和ptr_b 指向 new CB()两条引用，
• 然后调用函数set_ptr后又增加了m_ptr_a 指向 new CA() 和 m_ptr_b指向 new CB 两条引用，当test_refer_to_each_other这个函数返回时，对象ptr_a和ptr_b被销毁，
• 也就是【ptr_a 指向new_CA（） 和ptr_b 指向 new CB()两条引用 】会被断开，但是依然m_ptr_a 指向 new CA() 和 m_ptr_b指向 new CB 两条引用存在，
• 每一个的引用计数都不为0，结果就导致其指向的内部对象无法析构（不能调用析构函数），造成内存泄漏。

解决这种状况的办法就是将两个类中的一个成员变量改为weak_ptr对象，因为weak_ptr不会增加引用计数，使得引用形不成环，最后就可以正常的释放内部的对象，不会造成内存泄漏，比如将CB中的成员变量改为weak_ptr对象，代码如下：

  class CB;
    class CA
    {
    public:
        CA() { cout << "CA() called! " << endl; }
        ~CA() { cout << "~CA() called! " << endl; }
        void set_ptr(shared_ptr<CB> &ptr) { m_ptr_b = ptr; }
        void b_use_count() { cout << "b use count : " << m_ptr_b.use_count() << endl; }
        void show() { cout << "this is class CA!" << endl; }

    private:
        shared_ptr<CB> m_ptr_b;
    };
    /*
    todo 解决这种状况的办法就是将两个类中的一个成员变量改为weak_ptr对象，因为weak_ptr不会增加引用计数，使得引用形不成环，
    todo 最后就可以正常的释放内部的对象，不会造成内存泄漏，比如将CB中的成员变量改为weak_ptr对象，代码如下：
    */
    class CB
    {
    public:
        CB() { cout << "CB() called! " << endl; }
        ~CB() { cout << "~CB() called! " << endl; }
        void set_ptr(shared_ptr<CA> &ptr) { m_ptr_a = ptr; }
        void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
        void show() { cout << "this is class CB!" << endl; }

    private:
        weak_ptr<CA> m_ptr_a;
    };

    void test_refer_to_each_other()
    {
        shared_ptr<CA> ptr_a(new CA());
        shared_ptr<CB> ptr_b(new CB());

        cout << "a use count : " << ptr_a.use_count() << endl;
        cout << "b use count : " << ptr_b.use_count() << endl;

        ptr_a->set_ptr(ptr_b);
        ptr_b->set_ptr(ptr_a);

        cout << "a use count : " << ptr_a.use_count() << endl;
        cout << "b use count : " << ptr_b.use_count() << endl;
    }

测试结果如下：

CA() called!
CB() called!
a use count : 1
b use count : 1
a use count : 1
b use count : 2
~CA() called!
~CB() called!

• 通过这次结果可以看到，CA和CB的对象都被正常的析构了，*
• 但是不同的是m_ptr_a指向new CA()这条引用是通过weak_ptr建立的，并不会增加引用计数，也就是说CA的对象只有一个引用计数，*
• t而CB的对象只有2个引用计数，当test_refer_to_each_other这个函数返回时，对象ptr_a和ptr_b被销毁，
• 也就是 ptr_a 指向new_CA（） 和ptr_b 指向 new CB()两条引用 会被断开，此时CA对象的引用计数会减为0，对象被销毁，*
• *其内部的m_ptr_b成员变量也会被析构，导致CB对象的引用计数会减为0，对象被销毁，进而解决了引用成环的问题。

7移动语义

• 使用 std::move 可以将智能指针拥有权 转交给另一个智能指针，而不引起引用计数的增加

 void func()
    {
        cout << "detail6::func" << endl;
        shared_ptr<int> si = make_shared<int>(100);
        cout << "si.use_count()" << si.use_count() << endl;
        auto si2 = si;
        cout << "si.use_count()" << si.use_count() << endl;
        cout << "si2.use_count()" << si2.use_count() << endl;
    }
    void func2()
    {
        cout << "detail6::func2" << endl;
        shared_ptr<int> si = make_shared<int>(100);
        cout << "si.use_count()" << si.use_count() << endl;
        auto si2 = std::move(si);

        cout << "si.use_count()" << si.use_count() << endl;
        cout << "si2.use_count()" << si2.use_count() << endl;
    }

<< “detail6::func2” << endl;
shared_ptr si = make_shared(100);
cout << “si.use_count()” << si.use_count() << endl;
auto si2 = std::move(si);

    cout << "si.use_count()" << si.use_count() << endl;
    cout << "si2.use_count()" << si2.use_count() << endl;
}