铁锈破坏者和所有权

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的成员（结构字符串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的情况下，如果您仍然想使用它，则必须克隆该字段。