聊聊智能指针和所有权的问题

在编程语言中，对堆对象的内存管理是一个麻烦又复杂的问题。一不小心就会带来问题，比如JS里一直引用一个已经不使用的对象导致gc无法回收，或者C++里多个变量指向同一块内存导致重复释放。本文简单探讨一下关于对象所有权的问题。

创新互联长期为1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为随州企业提供专业的网站制作、成都做网站，随州网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。

对象的所有权意味着当我们分配一个对象的时候，谁持有这个对象的所有权，比如下面代码。

 
 
 
    
  
  
  
  1. Object *obj = new Object(); 
    2.

那么obj就持有了对象的所有权。但是现实往往比较复杂，比如我们看看下面代码。

 
 
 
    
  
  
  
  1. #include 
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6. class Demo { 
    7. 
  
  
  
  7.     public: 
    8. 
  
  
  
  8.     ~Demo(){ 
    9. 
  
  
  
  9.         printf("执行析构函数"); 
    10. 
  
  
  
  10.     }};void test() { 
    11. 
  
  
  
  11.     Demo *d = new Demo(); 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17. int main(){ 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.    test(); 
    20. 
  
  
  
  20.    return 0; 
    21. 
  
  
  
  21.  
    22. 
  
  
  
  22. } 
    23.

执行上面的代码，我们在test函数里分配一个堆对象，执行完test后我们发现Demo对象的析构函数并没有执行，这就造成了内存泄漏。那我们需要怎么做呢?我们需要收到释放对象对应的内存。修改一下test函数的代码。

 
 
 
    
  
  
  
  1. void test() { 
    2. 
  
  
  
  2.     Demo *d = new Demo(); 
    3. 
  
  
  
  3.     delete d; 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. } 
    6.

这时候我们发现就会输出执行析构函数几个字了，说明析构函数被执行，对象的内存也被释放了。手动管理内存不仅麻烦，而且往往容易出错，比如我们往往会忘了释放，尤其是代码逻辑复杂的时候。这时候，我们可以使用智能指针解决这个问题。

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. #include 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. using namespace std; 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11. class Demo { 
    12. 
  
  
  
  12.     public: 
    13. 
  
  
  
  13.     ~Demo(){ 
    14. 
  
  
  
  14.         printf("执行析构函数"); 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17. }; 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  
    20. 
  
  
  
  20. template 
    21. 
  
  
  
  21. class SmartPoint 
    22. 
  
  
  
  22. { 
    23. 
  
  
  
  23.     T* point; 
    24. 
  
  
  
  24. public: 
    25. 
  
  
  
  25.     SmartPoint(T *ptr = nullptr) :point(ptr) {} 
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.     ~SmartPoint() { 
    28. 
  
  
  
  28.         if (point) { 
    29. 
  
  
  
  29.             // 会调用point指向对象的的析构函数 
    30. 
  
  
  
  30.             delete point; 
    31. 
  
  
  
  31.         } 
    32. 
  
  
  
  32.     } 
    33. 
  
  
  
  33.     // 使用智能指针就像使用内部包裹的的对象一样 
    34. 
  
  
  
  34.     T& operator*() {  
    35. 
  
  
  
  35.         return *point;  
    36. 
  
  
  
  36.     } 
    37. 
  
  
  
  37.  
    38. 
  
  
  
  38.     T* operator->() {  
    39. 
  
  
  
  39.         return point;  
    40. 
  
  
  
  40.     } 
    41. 
  
  
  
  41.  
    42. 
  
  
  
  42. }; 
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.  
    45. 
  
  
  
  45.  
    46. 
  
  
  
  46. void test() { 
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48.     SmartPoint p(new Demo()); 
    49. 
  
  
  
  49.  
    50. 
  
  
  
  50. } 
    51. 
  
  
  
  51.  
    52. 
  
  
  
  52.  
    53. 
  
  
  
  53.  
    54. 
  
  
  
  54. int main(){ 
    55. 
  
  
  
  55.  
    56. 
  
  
  
  56.    test(); 
    57. 
  
  
  
  57.    return 0; 
    58. 
  
  
  
  58.  
    59. 
  
  
  
  59. } 
    60.

智能指针的原理比较简单，因为智能指针对象是在栈上面分配的，离开作用域的时候会被自动释放，然后在智能指针的析构函数里释放包裹的内部对象。看起来是很完美的解决方案。但是智能指针也带来了一些问题，那就是在复制或赋值的时候。我们看看代码。

 
 
 
    
  
  
  
  1. int main(){ 
    2. 
  
  
  
  2.    SmartPoint p(new Demo()); 
    3. 
  
  
  
  3.    SmartPoint p2 = p; 
    4. 
  
  
  
  4.    return 0; 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6. } 
    7.

执行下面代码会导致core dump，为什么呢?我们来看看这个过程。当执行p2=p的时候会导致p2和p的内部指针point都指向了Demo对象的地址，最后代码执行完毕后，两个智能指针都执行了释放内存的操作，重复释放内存导致了core dump。那如何解决这个问题呢?一种方式是复制一份point指向的内存，但是我们可能不知道这个内存多大，无法复制，另一种方式就是所有权转移。我们继续看代码。

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. #include 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. using namespace std; 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11. class Demo { 
    12. 
  
  
  
  12.     public: 
    13. 
  
  
  
  13.     ~Demo(){ 
    14. 
  
  
  
  14.         printf("执行析构函数"); 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17. }; 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  
    20. 
  
  
  
  20. template 
    21. 
  
  
  
  21. class SmartPoint 
    22. 
  
  
  
  22. { 
    23. 
  
  
  
  23.     T* point; 
    24. 
  
  
  
  24. public: 
    25. 
  
  
  
  25.     SmartPoint(T *ptr = nullptr) :point(ptr) {} 
    26. 
  
  
  
  26.     // 实现复制构造函数 
    27. 
  
  
  
  27.     SmartPoint(SmartPoint & p) {  
    28. 
  
  
  
  28.         // 指向p.point对应的内存 
    29. 
  
  
  
  29.         point = p.point; 
    30. 
  
  
  
  30.         // p.point置null 
    31. 
  
  
  
  31.         p.point = nullptr; 
    32. 
  
  
  
  32.     } 
    33. 
  
  
  
  33.     ~SmartPoint() { 
    34. 
  
  
  
  34.         if (point) { 
    35. 
  
  
  
  35.             // 会调用point指向对象的的析构函数 
    36. 
  
  
  
  36.             delete point; 
    37. 
  
  
  
  37.         } 
    38. 
  
  
  
  38.     } 
    39. 
  
  
  
  39.     // 使用智能指针就像使用内部包裹的的对象一样 
    40. 
  
  
  
  40.     T& operator*() {  
    41. 
  
  
  
  41.         return *point;  
    42. 
  
  
  
  42.     } 
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.     T* operator->() {  
    45. 
  
  
  
  45.         return point;  
    46. 
  
  
  
  46.     } 
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48. }; 
    49. 
  
  
  
  49.  
    50. 
  
  
  
  50.  
    51. 
  
  
  
  51.  
    52. 
  
  
  
  52. int main(){ 
    53. 
  
  
  
  53.  
    54. 
  
  
  
  54.    SmartPoint p(new Demo()); 
    55. 
  
  
  
  55.    SmartPoint p2 = p; 
    56. 
  
  
  
  56.    return 0; 
    57. 
  
  
  
  57.  
    58. 
  
  
  
  58. } 
    59.

我们实现了一个复制构造函数，在main里执行p2=p时会被执行，在复制构造函数中，我们实现了所有权转移，这时候p2时Demo对象的持有者，而p指向null，这时候不能再对p进行操作。这时候我们可以在SmartPoint中实现一个isNull函数用于判断智能指针的有效性。

 
 
 
    
  
  
  
  1. bool isNull() { 
    2. 
  
  
  
  2.     return point == nullptr;  
    3. 
  
  
  
  3. } 
    4.

然后在使用的地方加一下判断。

 
 
 
    
  
  
  
  1. if (p.isNull()) { 
    2. 
  
  
  
  2.     //  
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. } 
    5.

这显然很麻烦。我们看看Rust怎么做。

 
 
 
    
  
  
  
  1. struct Demo(u32); 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. fn main() { 
    4. 
  
  
  
  4.     let _box1 = Box::new(Demo(1)); 
    5. 
  
  
  
  5.     // 所有权转移 
    6. 
  
  
  
  6.     let _box2 = _box1; 
    7. 
  
  
  
  7.     // 报错 
    8. 
  
  
  
  8.     println!("{}", _box1.0); 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. } 
    11.

 编译上面代码会报错，是编译而不是运行，这就是Rust，在编译期就解决了这个问题。Box是智能指针，以上代码和刚才C++中的代码类似，当执行_box2=_box1的时候，堆对象的所有权就转移到了_box2，_box1相当于包裹了一个空指针，而Rust不允许你再访问_box1管理里的内存。

文章标题：聊聊智能指针和所有权的问题
网页地址：http://www.gawzjz.com/qtweb/news7/191507.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

关键词优化知识

同城分类信息

成都网络营销　　 　梅州网站建设　　 　bgp机房托管　　 　域名申请　　 　微信小程序　　 　自动门　　 　雅安服务器托管　　 　手机网站制作　　 　绵阳服务器托管　　 　四川成都网站建设　　 　电子商务商城网站　　 　新津网站运维　　 　重庆网站建设　　 　注册域名　　 　成都宣传海报　　 　虚拟主机　　 　重庆服务器托管　　 　移动网站建设　　 　重庆网站建设　　 　成都关键词SEO优化