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

开发 后端
在编程语言中,对堆对象的内存管理是一个麻烦又复杂的问题。一不小心就会带来问题,本文简单探讨一下关于对象所有权的问题。

[[414238]]

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

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

  1. Object *obj = new Object(); 

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. if (p.isNull()) { 
  2.     //  
  3.  

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

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

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

 

责任编辑:姜华 来源: 编程杂技
相关推荐

2011-01-07 09:19:35

Linux文件权限

2024-03-19 14:43:55

Rust编译所有权

2017-07-27 13:34:52

Rust所有权数据

2022-11-03 15:14:43

Linux文件权限

2022-03-18 08:00:00

区块链代币以太坊

2024-01-10 09:26:52

Rust所有权编程

2011-01-20 07:50:51

Linux文件系统管理所有权

2009-11-28 20:21:14

2011-03-03 15:40:55

PureFTPd

2023-10-10 11:04:11

Rust难点内存

2013-08-16 10:46:20

2022-05-30 00:19:13

元宇宙NFTWeb3

2022-08-11 10:42:58

Rust

2018-01-23 11:15:28

云计算数据平台云平台

2015-07-27 11:34:03

Linux内核指针

2009-09-12 09:46:47

Windows 7所有权添加

2017-10-23 12:42:42

2018-12-14 10:08:23

物联网订阅IOT

2020-09-09 09:19:00

SpringSecurity权限

2010-07-20 17:36:55

SQL Server
点赞
收藏

51CTO技术栈公众号