Rust 析构函数和所有权

Question

前几天我几乎问了同样的问题，但是在 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 的一个成员（struct string b）的 ownersnip 转移到另一个函数。但是 struct string b 将被 main 函数释放，因为我有一个规则，当一个对象超出范围时，我调用它的 destruct 函数。但我不希望 main 函数释放此资源。 TransferOwnershipFunction(...) 现在负责释放 object1 的这个成员。 Rust 编译器如何处理这种情况？在 Rust 中，我必须复制字符串 b 吗？

Answer 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 的情况下，如果您仍想使用它，则必须克隆该字段。

Rust 析构函数和所有权

Rust Destructors and ownership

c

destructor

memory-management

ownership