c - 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为结构实现，析构函数可能在字段之间有重要的交互；它们可能不会被单独丢弃。因此，这意味着结构必须保持为一个连贯的部分，直到它被删除。

例如，Drop Rc<T> 的实现检查是否有对剩余数据的任何(强)引用，如果没有，则删除基础数据。如果 Rc<T> 的字段(一个指针，一个强引用计数和一个弱引用计数)被分别删除，在删除指针时将无法检查还剩下多少强引用。如果仍然有强引用，就没有办法保留底层数据。

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