问题抛出：智能指针shared_ptr用weak_ptr打破循环引用

东方耀

问题抛出：智能指针shared_ptr用weak_ptr打破循环引用

1. #include <iostream>
   
2. #include <memory>
   
3. 
   
4. class Parent;   // 前置申明
   
5. typedef std::shared_ptr<Parent> ParentPtr;
   
6. 
   
7. class Child{
   
8.     public:
   
9.         ParentPtr father;
   
10.         Child();
    
11.         ~Child();
    
12. };
    
13. 
    
14. typedef std::shared_ptr<Child> ChildPtr;
    
15. class Parent{
    
16.     public:
    
17.         ChildPtr son;
    
18.         Parent();
    
19.         ~Parent();
    
20. };
    
21. 
    
22. Child::Child(){
    
23.     printf("hi child\n");
    
24. }
    
25. 
    
26. Parent::Parent(){
    
27.     printf("hi parent\n");
    
28. }
    
29. 
    
30. Child::~Child(){
    
31.     printf("bye child\n");
    
32. }
    
33. 
    
34. Parent::~Parent(){
    
35.     printf("bye parent\n");
    
36. }
    
37. 
    
38. void test_parent_and_child(){
    
39.     ParentPtr p(new Parent());
    
40.     ChildPtr c(new Child());
    
41.     printf("use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
42.     // 问题出在：下面2行代码中 没有析构 内存泄露
    
43.     p->son = c;
    
44.     printf("循环指use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
45.     c->father = p;
    
46.     printf("循环指use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
47. 
    
48.     // 该语句块结束后 会自动析构 导致use_count会减1 最终引用数都是1 相互等待 进入死循环 导致对象不析构
    
49. 
    
50. }
    
51. 
    
52. 
    
53. 
    
54. int main(){
    
55.     printf("问题抛出：智能指针shared_ptr用weak_ptr打破循环引用.cpp\n");
    
56.     test_parent_and_child();
    
57.     // shared_ptr_with_weak_ptr();
    
58.     return 0;
    
59. }

复制代码

东方耀

参考这个用法：http://www.ai111.vip/thread-1261-1-1.html
改进如下：

1. #include <iostream>
   
2. #include <memory>
   
3. 
   
4. class Parent;   // 前置申明
   
5. //weak_ptr只能与shared_ptr结合使用，不能单独使用
   
6. typedef std::shared_ptr<Parent> ParentPtr;
   
7. typedef std::weak_ptr<Parent> ParentPtr_weak;
   
8. 
   
9. 
   
10. class Child{
    
11.     public:
    
12.         ParentPtr_weak father;  //只用一个即可 打破了循环引用
    
13.         Child();
    
14.         ~Child();
    
15. };
    
16. 
    
17. typedef std::shared_ptr<Child> ChildPtr;
    
18. typedef std::weak_ptr<Child> ChildPtr_weak;
    
19. class Parent{
    
20.     public:
    
21.         ChildPtr_weak son;    // 两个都改 更符合对象析构的顺序吧
    
22.         Parent();
    
23.         ~Parent();
    
24. };
    
25. 
    
26. Child::Child(){
    
27.     printf("hi child\n");
    
28. }
    
29. 
    
30. Parent::Parent(){
    
31.     printf("hi parent\n");
    
32. }
    
33. 
    
34. Child::~Child(){
    
35.     printf("bye child\n");
    
36. }
    
37. 
    
38. Parent::~Parent(){
    
39.     printf("bye parent\n");
    
40. }
    
41. 
    
42. void test_parent_and_child(){
    
43.     ParentPtr p(new Parent());
    
44.     ChildPtr c(new Child());
    
45.     printf("use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
46.     // 问题出在：下面2行代码中 没有析构 内存泄露
    
47.     p->son = c;  // 又是用强指针赋值给弱指针
    
48.     //Object_weak_ptr weak_obj(obj); //一般通过shared_ptr来构建weak_ptr
    
49.     printf("循环指use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
50.     c->father = p;
    
51.     printf("循环指use_count()=%ld,%ld\n", p.use_count(), c.use_count());
    
52. 
    
53.     // 该语句块结束后 会自动析构 导致use_count会减1 最终引用数都是1 相互等待 进入死循环 导致对象不析构
    
54. 
    
55. }
    
56. 
    
57. 
    
58. 
    
59. int main(){
    
60.     printf("问题抛出：智能指针shared_ptr用weak_ptr打破循环引用.cpp\n");
    
61.     test_parent_and_child();
    
62.     // shared_ptr_with_weak_ptr();
    
63.     return 0;
    
64. }

复制代码

zouqiqi

让天下人人学会人工智能！人工智能的前景一片大好！