在编程语言中,对堆对象的内存管理是一个麻烦又复杂的问题。一不小心就会带来问题,比如JS里一直引用一个已经不使用的对象导致gc无法回收,或者C++里多个变量指向同一块内存导致重复释放。本文简单探讨一下关于对象所有权的问题。
对象的所有权意味着当我们分配一个对象的时候,谁持有这个对象的所有权,比如下面代码。
- Object *obj = new Object();
那么obj就持有了对象的所有权。但是现实往往比较复杂,比如我们看看下面代码。
- #include
- using namespace std;
-
-
-
- class Demo {
- public:
- ~Demo(){
- printf("执行析构函数");
- }};void test() {
- Demo *d = new Demo();
-
- }
-
-
-
- int main(){
-
- test();
- return 0;
-
- }
执行上面的代码,我们在test函数里分配一个堆对象,执行完test后我们发现Demo对象的析构函数并没有执行,这就造成了内存泄漏。那我们需要怎么做呢?我们需要收到释放对象对应的内存。修改一下test函数的代码。
- void test() {
- Demo *d = new Demo();
- delete d;
-
- }
这时候我们发现就会输出执行析构函数几个字了,说明析构函数被执行,对象的内存也被释放了。手动管理内存不仅麻烦,而且往往容易出错,比如我们往往会忘了释放,尤其是代码逻辑复杂的时候。这时候,我们可以使用智能指针解决这个问题。
- #include
-
- #include
-
-
-
- using namespace std;
-
-
-
- class Demo {
- public:
- ~Demo(){
- printf("执行析构函数");
- }
-
- };
-
-
- template
- class SmartPoint
- {
- T* point;
- public:
- SmartPoint(T *ptr = nullptr) :point(ptr) {}
-
- ~SmartPoint() {
- if (point) {
- // 会调用point指向对象的的析构函数
- delete point;
- }
- }
- // 使用智能指针就像使用内部包裹的的对象一样
- T& operator*() {
- return *point;
- }
-
- T* operator->() {
- return point;
- }
-
- };
-
-
-
- void test() {
-
- SmartPoint
p(new Demo()); -
- }
-
-
-
- int main(){
-
- test();
- return 0;
-
- }
智能指针的原理比较简单,因为智能指针对象是在栈上面分配的,离开作用域的时候会被自动释放,然后在智能指针的析构函数里释放包裹的内部对象。看起来是很完美的解决方案。但是智能指针也带来了一些问题,那就是在复制或赋值的时候。我们看看代码。
- int main(){
- SmartPoint
p(new Demo()); - SmartPoint
p2 = p; - return 0;
-
- }
执行下面代码会导致core dump,为什么呢?我们来看看这个过程。当执行p2=p的时候会导致p2和p的内部指针point都指向了Demo对象的地址,最后代码执行完毕后,两个智能指针都执行了释放内存的操作,重复释放内存导致了core dump。那如何解决这个问题呢?一种方式是复制一份point指向的内存,但是我们可能不知道这个内存多大,无法复制,另一种方式就是所有权转移。我们继续看代码。
- #include
-
- #include
-
-
-
- using namespace std;
-
-
-
- class Demo {
- public:
- ~Demo(){
- printf("执行析构函数");
- }
-
- };
-
-
- template
- class SmartPoint
- {
- T* point;
- public:
- SmartPoint(T *ptr = nullptr) :point(ptr) {}
- // 实现复制构造函数
- SmartPoint(SmartPoint & p) {
- // 指向p.point对应的内存
- point = p.point;
- // p.point置null
- p.point = nullptr;
- }
- ~SmartPoint() {
- if (point) {
- // 会调用point指向对象的的析构函数
- delete point;
- }
- }
- // 使用智能指针就像使用内部包裹的的对象一样
- T& operator*() {
- return *point;
- }
-
- T* operator->() {
- return point;
- }
-
- };
-
-
-
- int main(){
-
- SmartPoint
p(new Demo()); - SmartPoint
p2 = p; - return 0;
-
- }
我们实现了一个复制构造函数,在main里执行p2=p时会被执行,在复制构造函数中,我们实现了所有权转移,这时候p2时Demo对象的持有者,而p指向null,这时候不能再对p进行操作。这时候我们可以在SmartPoint中实现一个isNull函数用于判断智能指针的有效性。
- bool isNull() {
- return point == nullptr;
- }
然后在使用的地方加一下判断。
- if (p.isNull()) {
- //
-
- }
这显然很麻烦。我们看看Rust怎么做。
- struct Demo(u32);
-
- fn main() {
- let _box1 = Box::new(Demo(1));
- // 所有权转移
- let _box2 = _box1;
- // 报错
- println!("{}", _box1.0);
-
- }
编译上面代码会报错,是编译而不是运行,这就是Rust,在编译期就解决了这个问题。Box是智能指针,以上代码和刚才C++中的代码类似,当执行_box2=_box1的时候,堆对象的所有权就转移到了_box2,_box1相当于包裹了一个空指针,而Rust不允许你再访问_box1管理里的内存。