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

在编程语言中，对堆对象的内存管理是一个麻烦又复杂的问题。一不小心就会带来问题，比如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.  
17. int main(){ 
18.  
19.    test(); 
20.    return 0; 
21.  
22. } 

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

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

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

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. { 
23.     T* point; 
24. public: 
25.     SmartPoint(T *ptr = nullptr) :point(ptr) {} 
26.  
27.     ~SmartPoint() { 
28.         if (point) { 
29.             // 会调用point指向对象的的析构函数 
30.             delete point; 
31.         } 
32.     } 
33.     // 使用智能指针就像使用内部包裹的的对象一样 
34.     T& operator*() {  
35.         return *point;  
36.     } 
37.  
38.     T* operator->() {  
39.         return point;  
40.     } 
41.  
42. }; 
43.  
44.  
45.  
46. void test() { 
47.  
48.     SmartPoint<Demo> p(new Demo()); 
49.  
50. } 
51.  
52.  
53.  
54. int main(){ 
55.  
56.    test(); 
57.    return 0; 
58.  
59. } 

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

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

执行下面代码会导致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. { 
23.     T* point; 
24. public: 
25.     SmartPoint(T *ptr = nullptr) :point(ptr) {} 
26.     // 实现复制构造函数 
27.     SmartPoint(SmartPoint & p) {  
28.         // 指向p.point对应的内存 
29.         point = p.point; 
30.         // p.point置null 
31.         p.point = nullptr; 
32.     } 
33.     ~SmartPoint() { 
34.         if (point) { 
35.             // 会调用point指向对象的的析构函数 
36.             delete point; 
37.         } 
38.     } 
39.     // 使用智能指针就像使用内部包裹的的对象一样 
40.     T& operator*() {  
41.         return *point;  
42.     } 
43.  
44.     T* operator->() {  
45.         return point;  
46.     } 
47.  
48. }; 
49.  
50.  
51.  
52. int main(){ 
53.  
54.    SmartPoint<Demo> p(new Demo()); 
55.    SmartPoint<Demo> p2 = p; 
56.    return 0; 
57.  
58. } 

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

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

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

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

这显然很麻烦。我们看看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.  
10. } 

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

原文链接：https://mp.weixin.qq.com/s/bfZ-C7NsovyfxM8BP5Xx8A