智能指针之shared_ptr易错点05

一 shared_ptr易错点

1 慎用裸指针给shared_ptr赋值

例1

class A {
public:
    A() {};
    A(int i) {
        m_i=i;
        cout<<"A"<<endl;
    };
    void SetI(int i) {m_i=i;};
    int GetI(){return m_i;}
    ~A() {
        cout<<"~A"<<endl;
    };
private:
    int m_i;
};

void proc1(shared_ptr<int> ptr)
{
    return;
}

void proc2(shared_ptr<A> ptr)
{
    return;
}

void test13()
{
    int *p1 = new int(100);
    //proc(p); //语法错误，int *p不能转换成shared_ptr<int>（不支持隐式转换）
    proc1(shared_ptr<int>(p1)); 
    *p1 = 45; //潜在的不可预料的问题，因为p已经被释放了
}

void test14(){
    A *p2 = new A(100);
    proc2(shared_ptr<A>(p2));//A构造只会被调用一次执行完proc2
    *p2 = 50;//错误1，系统会帮你重新开辟A对象，但是仍会报错，这就是不可预料的问题之一
    //p2->SetI(45); //错误2，系统未重新开辟对象
}

当我界面直接断点调试test13时，它执行到 *p1 = 45;没有报错，但是程序最终结束时却卡死，说明程序出现问题。然后我们又通过gdb调试一遍(命令行模式)，它的错误就明显报错了。

然后我又测试了test14，是shared_ptr存储自定义对象的。结果发现又出现不同的错误或称不可预料的错误，当p2在调完proc2函数后，p2就被释放了，我再次违法使用*p2=50时，系统会重新开辟A内存，但是最终也会报错。

而测试p2->SetI(45);错误时与test13错误一样。

例2
同上面一样，均是用一个裸指针给多个shared_ptr赋值，导致释放多次。

int *p = new int(12);
shared_ptr<int> p1(p);
shared_ptr<int> p2(p);   //不可以！！！！这种写法p1和p2无关联，会导致p1和p2所指向的 
                         //内存被释放两次，产生异常

正确的用裸指针赋值应该是下面的方法：

shared_ptr<int> p1(new int());
shared_ptr<int> p2(p1);   //这种写法可以，p1与p2用的是同一个控制块，两者互通

所以我们一定要慎用用裸指针赋值，或者说，使用裸指针赋值的方式只能用上面正确的写法。

2 慎用get()返回的指针(智能指针返回对应的裸指针)

shared_ptr<int> myp(new int(122));
int *p = myp.get();
delete p;   //不可以释放！！！！！！！！！！！！！！！
 
shared_ptr<int> myp2(p); //不可以！！！myp和myp2的引用计数都为1，实际这种错误就是上面多次使用裸指针赋值

3 禁用使用this给shared_ptr赋值，然后返回类对象本身

这种错误本来属于第1大点的错误点，即使用一个裸指针给多个shared_ptr赋值，但是由于返回类对象本身比较重要，所以单独拿出来分析。
错误写法：

class CT
{
public:
    shared_ptr<CT> getself()
    {
        return shared_ptr<CT>(this); //该this已经被一个shared_ptr管理，但是现在却又被新的shared_ptr管理，必然报错
    }
};
 
shared_ptr<CT> pct1(new CT());
shared_ptr<CT> pct2 = pct1->getself(); //不可以pct1与pct2虽然指向同一内存，但是pct1和pct2两个毫无关系，引用计数均为1

正确写法应该是使用enable_shared_from_this类模板返回。
enable_shared_from_this的工作原理：enable_shared_from_this有一个弱指针，当我们创建了一个share_ptr，该弱指针就会被初始化赋值，但是引用数不会加1，然后当我们调用shared_from_this时，就能返回通过weak_ptr赋值的share_ptr。这样就可以获取到对象本身。

class CT: enable_shared_from_this<CT>//必须继承enable_shared_from_this
{
public:
    shared_ptr<CT> getself()
    {
        return shared_from_this(); //正确写法
   }
};
 
shared_ptr<CT> pct1(new CT());
shared_ptr<CT> pct2 = pct1->getself(); 

具体关于enable_shared_from_this源码分析的，请看我这篇博客分析。

https://blog.csdn.net/weixin_44517656/article/details/114195265

4 shared_ptr的循环引用问题

//3.2 shared_ptr的循环引用
class Children;    //声明

class Parent
{
public:
    ~Parent()
    {
        cout << "Parent    destructor" << endl;
    }

    shared_ptr<Children> s_children1;
};

class Children
{
public:
    ~Children()
    {
        cout << "Children  destructor" << endl;
    }
    shared_ptr<Parent> s_parent1;
};

void test04()
{
    shared_ptr<Parent>   s_parent(new Parent());      //1 调用拷贝对象构造 使s_parent指向Parent共享资源
    shared_ptr<Children> s_children(new Children());  //调用拷贝对象构造 使s_children指向Children共享资源
    if(s_parent && s_children)                        //两个对象成功创建的话
    {
        s_parent   -> s_children1 = s_children;       //2 使对象成员也指向Children共享资源
        s_children -> s_parent1   = s_parent;         //使对象成员也指向Parent共享资源
    }

    cout << "s_parent use_count: " << s_parent.use_count() << endl;     // 2
    cout << "s_children use_count: " << s_children.use_count() << endl; // 2
}

执行上面程序可以知道，析构并没有被调用，内存泄漏，解决方法是将成员变量其中一个改成weak_ptr，因为weak_ptr不占用引用数。以第一个变成weak_ptr为例，当两个shared对象释放时，成员对象s_children1不占用引用数，s_children(图下面那个)引用的count从1变成0，所以他可以调用析构函数析构掉它；而被析构时，他的成员变量s_parent1也会被析构，由于shared对象释放时减了1，所以count引用也变成了0，两个内存被释放，这样就解决了这个循环引用问题。

构造执行了，且Children对象先被析构。因为s_children指向对象的引用先变为0先嘛。若改成第二个为weak，那么就s_parent指向的对象被析构，即Parent对象。

5 补充说明和使用建议

5.1 移动语义
移动语义是可以使用的，但是注意不要乱用，因为它所有权被夺走后相当于空。

void test15(){
    shared_ptr<int> p1(new int(100));
    //移动语义，夺走p1内存所有权给一个新的智能指针p2管理,移动后p1就不能再管理该内存（变成空），引用计数依旧是1
    shared_ptr<int> p2(std::move(p1)); 
    //*p1 = 50;//报错
    if(p1 == nullptr){
        cout<<"p1被置空,count=" << p1.use_count() << endl;
    }
    if(p2 != nullptr){
        cout<<"p2通过move夺走p1所有权, count=" << p2.use_count() << endl;
    }
 
    shared_ptr<int> p3;
    //移动赋值,p2指向空,p3指向该对象,整个对象的引用计数仍然为1
    p3 = std::move(p2); 
    if(p2 == nullptr){
        cout<<"p2被置空,count=" << p2.use_count() << endl;
    }
    if(p3 != nullptr){
        cout<<"p3通过move夺走p2所有权, count=" << p3.use_count() << endl;
    }
}

结果：

而当我们移动后再使用空的对象，则会报错，所以也要慎用。

5.2 建议

• 1）谨慎使用，奇怪用法不要轻易尝试。
• 2）优先使用make_shared()。
  具体下面这两种的优势和劣势参考我这一篇-文章->智能指针之shared_ptr初始化，引用计数，常用操作和自定义删除器等等03。

shared_ptr<string> ps1(new string("good luck"));  //需要分配两次内存
auto ps2 = make_shared<string>("good luck");  //只分配一次