shared_ptr的问题

#include <iostream>
#include <string>
#include <memory>

using namespace std;

class Girl;

class Boy{
    public:
        Boy(){
             cout << "Boy 构造函数" << endl;
        }   
    
        ~Boy(){
             cout << "~Boy 析构函数" <<endl;
        }   

        void setGirlFriend(shared_ptr<Girl> _girlFriend){
             this->girlFriend = _girlFriend;
        }   

    private:
        shared_ptr<Girl> girlFriend;
};

class Girl{
    public:
        Girl(){
          cout << "Girl 构造函数" <<endl;
        }   

        ~Girl(){
          cout << "~Girl 构造函数" <<endl;
        }   
         void setBoyFriend(shared_ptr<Boy> _boyFriend){
             this->boyFriend = _boyFriend;
        }
    private:
        shared_ptr<Boy> boyFriend;
};

void useTrap(){
     shared_ptr<Boy> spBoy(new Boy());
     shared_ptr<Girl> spGirl(new Girl());

     //陷阱用法
     spBoy->setGirlFriend(spGirl);
     spGirl->setBoyFriend(spBoy);

}


int main(void){
    useTrap();

    return 0;

}

最后的运行情况：

root@maokx:~/learn/smartPoint# g++ -std=c++11 -g test6.cpp -o test6
root@maokx:~/learn/smartPoint# ./test6
Boy 构造函数
Girl 构造函数
root@maokx:~/learn/smartPoint# 

发现没有调用析构函数，为什么呢？
useTrap函数结束后，函数中定义的智能指针被清掉，boy和girl指针的引用计数减1，还剩下1，对象中的智能指针还是托管他们的，所以函数结束后没有将boy和gilr指针释放的原因就是于此。

当我们执行useTrap函数时，注意，是没有结束此函数，boy和girl指针其实是被两个智能指针托管的，所以他们的引用计数是2：

image.png

从图中可知：
无法释放的原因是：循环引用
这种情况，很像类的头文件的循环引用，释放spBoy,必须谢谢spGirl,释放spGirl的话，必须释放spBoy,这就是死循环的情况，所以这种不行。

weak_ptr指针

weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。 同时weak_ptr 没有重载*和->但可以使用 lock 获得一个可用的 shared_ptr 对象。

弱指针的使用：
weak_ptr wpGirl_1; // 定义空的弱指针
weak_ptr wpGirl_2(spGirl); // 使用共享指针构造
wpGirl_1 = spGirl; // 允许共享指针赋值给弱指针
弱指针也可以获得引用计数；
wpGirl_1.use_count()
弱指针不支持 * 和 -> 对指针的访问；

#include <iostream>
#include <string>
#include <memory>

using namespace std;

class Girl;

class Boy{
    public:
        Boy(){
               cout << "Boy 构造函数" <<endl;
        }

        ~Boy(){
               cout << "~Boy 析构函数" <<endl;
        }

        void setGirlFriend(shared_ptr<Girl> _girlFriend){
             this->girlFriend = _girlFriend;

             //在必要使用可以转换成共享指针
             shared_ptr<Girl> sp_girl;
             sp_girl = this->girlFriend.lock();

             cout << sp_girl.use_count() <<endl;
             //使用完之后，再将共享指针NULL即可
             sp_girl = NULL;
        }

    private:
             weak_ptr<Girl> girlFriend;
};


class Girl{
                                  
   public:
        Girl(){
            cout << "Girl 构造函数" <<endl;
        }
        ~Girl(){
            cout << "~Girl 析构函数" << endl;
        }

        void setBoyFriend(shared_ptr<Boy> _boyFriend){
             this->boyFriend = _boyFriend;
        }

    private:
        shared_ptr<Boy> boyFriend;
};


void useTrap(){
     shared_ptr<Boy> spBoy(new Boy());
     shared_ptr<Girl> spGirl(new Girl());

     spBoy->setGirlFriend(spGirl);
     spGirl->setBoyFriend(spBoy);
}

int main(void){
    useTrap();

    return 0;

}

运行情况：

root@maokx:~/learn/smartPoint# g++ -std=c++11 -g test7.cpp -o test7
root@maokx:~/learn/smartPoint# ./test7
Boy 构造函数
Girl 构造函数
3
~Girl 析构函数
~Boy 析构函数
root@maokx:~/learn/smartPoint# 

这样就调用了析构函数，弱关联，就打破了相互引用的情况。
在类中使用弱指针接管共享指针，在需要使用时就转换成共享指针去使用即可！

注意的事项

不要把一个原生指针给多个智能指针管理;
int *x = new int(10);
unique_ptr< int > up1(x);
unique_ptr< int > up2(x);

// 警告! 以上代码使up1 up2指向同一个内存,非常危险
或以下形式：
up1.reset(x);
up2.reset(x);
这样可以，引起重复释放的问题，类似两次delete

记得使用u.release()的返回值;
在调用u.release()时是不会释放u所指的内存的，这时返回值就是对这块内存的唯一索引，如果没有使用这个返回值释放内存或是保存起来，这块内存就泄漏了.
这个名字很容易让人误解

禁止delete 智能指针get 函数返回的指针;
如果我们主动释放掉get 函数获得的指针，那么智能 指针内部的指针就变成野指针了，析构时造成重复释放，带来严重后果!
禁止用任何类型智能指针get 函数返回的指针去初始化另外一个智能指针！
shared_ptr< int > sp1(new int(10));
// 一个典型的错误用法 shared_ptr< int > sp4(sp1.get());
既然已经托管指针了，那么，自己不要去管理了或者乱用了，就依靠托管的管理就可以了

最后的总结

智能指针虽然使用起来很方便，但是要注意使用智能指针的一些陷阱，否则会造成严重的内存报错或者内存泄露等问题！