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：
从图中可知：
无法释放的原因是：循环引用
这种情况，很像类的头文件的循环引用，释放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());
既然已经托管指针了，那么，自己不要去管理了或者乱用了，就依靠托管的管理就可以了
最后的总结
智能指针虽然使用起来很方便，但是要注意使用智能指针的一些陷阱，否则会造成严重的内存报错或者内存泄露等问题！
