weak_ptr
weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作,它可以从一个shared_ptr或另一个weak_ptr对象构造,它的构造和析构不会引起引用计数的增加或减少。没有重载 *和 -> 但可以使用lock获得一个可用的shared_ptr对象
weak_ptr的使用更为复杂一点,它可以指向shared_ptr指针指向的对象内存,却并不拥有该内存,而使用weak_ptr成员lock,则可返回其指向内存的一个share_ptr对象,且在所指对象内存已经无效时,返回指针空值nullptr。
注意:weak_ptr并不拥有资源的所有权,所以不能直接使用资源。 可以从一个weak_ptr构造一个shared_ptr以取得共享资源的所有权。
#include <iostream> #include <string> #include <memory> #include <vector> #include <map> void check(std::weak_ptr<int> &wp) { std::shared_ptr<int> sp = wp.lock(); // 转换为shared_ptr<int> if (sp != nullptr) { std::cout << "still: " << *sp << std::endl; } else { std::cout << "still: " << "pointer is invalid" << std::endl; } } int main() { std::shared_ptr<int> sp1(new int(22)); std::shared_ptr<int> sp2 = sp1; std::weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象 std::cout << "count: " << wp.use_count() << std::endl; // count: 2 std::cout << *sp1 << std::endl; // 22 std::cout << *sp2 << std::endl; // 22 check(wp); // still: 22 sp1.reset(); std::cout << "count: " << wp.use_count() << std::endl; // count: 1 std::cout << *sp2 << std::endl; // 22 check(wp); // still: 22 sp2.reset(); std::cout << "count: " << wp.use_count() << std::endl; // count: 0 check(wp); // still: pointer is invalid return 0; }
count: 2 22 22 still: 22 count: 1 22 still: 22 count: 0 still: pointer is invalid
#include <iostream> #include <string> #include <memory> #include <vector> #include <map> void check(std::weak_ptr<int> &wp) { std::shared_ptr<int> sp = wp.lock(); // 转换为shared_ptr<int> if (sp != nullptr) { std::cout << "still: " << *sp << std::endl; } else { std::cout << "still: " << "pointer is invalid" << std::endl; } } int main() { std::shared_ptr<int> sp1(new int(22)); std::shared_ptr<int> sp2 = sp1; std::weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象 *wp; return 0;
root@ubuntu:~/c++# g++ -std=c++11 weak.cpp -o weak weak.cpp: In function ‘int main()’: weak.cpp:22:5: error: no match for ‘operator*’ (operand type is ‘std::weak_ptr<int>’) *wp; ^
没有重载 *和 ->
- 为什么要使用weak_ptr
weak_ptr解决shared_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; }; 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; } // 测试结果 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时,只有①③两条引用,然后调用函数set_ptr后又增加了②④两条引用,当test_refer_to_each_other这个函数返回时,对象ptr_a和ptr_b被销毁,也就是①③两条引用会被断开,但是②④两条引用依然存在,每一个的引用计数都不为0,结果就导致其指向的内部对象无法析构,造成内存泄漏。
解决这种状况的办法就是将两个类中的一个成员变量改为weak_ptr对象,因为weak_ptr不会增加引用计数,使得引用形不成环,最后就可以正常的释放内部的对象,不会造成内存泄漏,比如将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; }; // 测试结果 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的对象都被正常的析构了,引用关系如下图所示,流程与上一例子相似,但是不同的是④这条引用是通过weak_ptr建立的,并不会增加引用计数,也就是说CA的对象只有一个引用计数,而CB的对象只有2个引用计数,当test_refer_to_each_other这个函数返回时,对象ptr_a和ptr_b被销毁,也就是①③两条引用会被断开,此时CA对象的引用计数会减为0,对象被销毁,其内部的m_ptr_b成员变量也会被析构,导致CB对象的引用计数会减为0,对象被销毁,进而解决了引用成环的问题。
weak_ptr 注意事项
————————————————
// 编译错误 // error C2665: “std::weak_ptr<CA>::weak_ptr”: 3 个重载中没有一个可以转换所有参数类型 // weak_ptr<CA> ptr_1(new CA()); // 编译错误 // error C2440 : “初始化”: 无法从“std::weak_ptr<CA>”转换为“std::shared_ptr<CA>” // shared_ptr<CA> ptr_3 = wk_ptr; // 编译错误 // 编译必须作用于相同的指针类型之间 // wk_ptr_a.swap(wk_ptr_b); // 调用交换函数 // 编译错误 // 编译必须作用于相同的指针类型之间 // wk_ptr_b = wk_ptr_a; ————————————————
weak_ptr中只有函数lock和expired两个函数比较重要,因为它本身不会增加引用计数,所以它指向的对象可能在它用的时候已经被释放了,所以在用之前需要使用expired函数来检测是否过期,然后使用lock函数来获取其对应的shared_ptr对象,然后进行后续操作:
void test2() { shared_ptr<CA> ptr_a(new CA()); // 输出:CA() called! shared_ptr<CB> ptr_b(new CB()); // 输出:CB() called! cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 输出:ptr_a use count : 1 cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 输出:ptr_b use count : 1 weak_ptr<CA> wk_ptr_a = ptr_a; weak_ptr<CB> wk_ptr_b = ptr_b; if (!wk_ptr_a.expired()) { wk_ptr_a.lock()->show(); // 输出:this is class CA! } if (!wk_ptr_b.expired()) { wk_ptr_b.lock()->show(); // 输出:this is class CB! } wk_ptr_b.reset(); // 将wk_ptr_b的指向清空 if (wk_ptr_b.expired()) { cout << "wk_ptr_b is invalid" << endl; // 输出:wk_ptr_b is invalid 说明改指针已经无效 } wk_ptr_b = ptr_b; if (!wk_ptr_b.expired()) { wk_ptr_b.lock()->show(); // 输出:this is class CB! 调用赋值操作后,wk_ptr_b恢复有效 } // 最后输出的引用计数还是1,说明之前使用weak_ptr类型赋值,不会影响引用计数 cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 输出:ptr_a use count : 1 cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 输出:ptr_b use count : 1 }