Rust 析构函数和所有权答案

【问题标题】：Rust Destructors and ownershipRust 析构函数和所有权
【发布时间】：2020-02-16 09:28:17
【问题描述】：

前几天我几乎问了同样的问题，但在 c++ 的上下文中。

我尝试在我的 c 编程中复制析构函数和构造函数。这意味着对于每个对象或结构，都有一个初始化函数和一个析构函数，它们可以像这样释放所有对象资源：

struct MyObject {
  struct string a;
  struct string b;
  struct string c;
};

 void ConstructMyObject(struct MyObject *obj) {
   ConstructString(&obj->a);
   ConstructString(&obj->b);
   ConstructString(&obj->c);
}

 void DestructMyObject(struct MyObject *obj) {
   DestructString(&obj->a);
   DestructString(&obj->b);
   DestructString(&obj->c);
}

destruct 函数在每个函数作用域的末尾被调用，就像在 Rust 中一样，只是我手动将它放在那里而不是编译器为我做这项工作。所以现在在DestructMyObject 函数中，我调用每个结构字符串类型的析构函数，因为对于结构字符串对象，我也会像为结构 MyObject 对象一样编写一个析构函数。所以struct MyObject分配的所有东西都会被释放。

我的问题示例：

int main {
 struct MyObject Object1;
 ConstructMyObject(&Object1);
 ...
 ...
 ...
 TransferOwnershipFunction(Object1.b); /*takes a struct string object as argument*/
 ...
 ...
 ...

 DestructMyObject(&Object1);

 return 0;
}

我将 Object1 的成员（结构字符串 b）的 ownernip 转移到另一个函数。但是struct string b 将被main 函数释放，因为我有一个规则，当一个对象超出范围时，我调用它的destruct 函数。但我不希望 main 函数释放此资源。 TransferOwnershipFunction(...) 现在负责释放 object1 的这个成员。 Rust 编译器如何处理这种情况？在 Rust 中，我是否必须克隆字符串 b？

【问题讨论】：

标签： c memory-management destructor ownership

【解决方案1】：

Rust 编译器足够智能，可以查看何时仅使用了结构的单个字段。只有该特定字段的所有权转移，其余字段在范围结束时被删除（或以其他方式使用）。这可以在以下示例中看到。

struct MyObject {
    a: String,
    b: String,
    c: String,
}

fn consume_string(_string: String) {}

fn main() {
    let object = MyObject {
        a: "".to_string(),
        b: "".to_string(),
        c: "".to_string(),
    };
    consume_string(object.b);
    // We can still access object.a and object.c
    println!("{}", object.a);
    println!("{}", object.c);
    // but not object.b
    // println!("{}", object.b);
}

(playground)

但是，如果结构具有非平凡的析构函数，即实现 Drop 特征，则不会发生这种情况。尝试移动结构的单个字段将导致编译器错误，如下所示。

struct MyObject {
    a: String,
    b: String,
    c: String,
}

// This is new
impl Drop for MyObject {
    fn drop(&mut self) {
        println!("dropping MyObject");
    }
}

fn consume_string(_string: String) {}

fn main() {
    let object = MyObject {
        a: "".to_string(),
        b: "".to_string(),
        c: "".to_string(),
    };
    consume_string(object.b);
}

尝试编译会报错

error[E0509]: cannot move out of type `MyObject`, which implements the `Drop` trait
  --> src/main.rs:22:20
   |
22 |     consume_string(object.b);
   |                    ^^^^^^^^
   |                    |
   |                    cannot move out of here
   |                    move occurs because `object.b` has type `std::string::String`, which does not implement the `Copy` trait

error: aborting due to previous error

For more information about this error, try `rustc --explain E0509`.
error: Could not compile `playground`.

(playground) ([E0509])

我认为您已经理解了其中的原因，但值得重复。如果为结构实现Drop，则析构函数可能在字段之间进行非平凡的交互；它们可能不只是被独立丢弃。所以这意味着结构必须保持一个连贯的部分，直到它被丢弃。

例如，Rc<T> 的 Drop 实现检查是否存在对剩余数据的任何（强）引用，如果没有，则删除基础数据。如果Rc<T> 的字段（一个指针、一个强引用计数和一个弱引用计数）分别被丢弃，那么在丢弃指针时将无法检查剩下多少强引用。如果仍然存在强引用，则无法保留基础数据。

如您所料，在实现Drop 的情况下，如果您仍想使用该字段，则必须克隆该字段。

【讨论】：