面试题：Rust析构函数与所有权系统的交互

析构函数处理资源清理的方式
- 在Rust中，当一个结构体实例超出作用域时，其析构函数（Drop trait的实现）会被自动调用，按照成员声明的顺序逆序清理成员的资源。
- 对于不同所有权语义的成员，Rust的所有权系统确保资源被正确管理。例如，对于拥有所有权的成员，析构函数会释放其占用的资源；对于借用的成员，析构函数不会尝试释放其资源，因为它们的生命周期由外部控制。
代码示例

struct Inner {
    data: String,
}

impl Drop for Inner {
    fn drop(&mut self) {
        println!("Dropping Inner with data: {}", self.data);
    }
}

struct Outer {
    inner: Inner,
    borrowed_ref: &'static str,
}

impl Drop for Outer {
    fn drop(&mut self) {
        println!("Dropping Outer");
    }
}

fn main() {
    let inner = Inner {
        data: "Hello, Rust!".to_string(),
    };
    let outer = Outer {
        inner,
        borrowed_ref: "Static string",
    };
    // 当`outer`超出作用域时，`Outer`的析构函数会被调用，
    // 然后`Inner`的析构函数会被调用
}

在上述代码中：

Inner结构体拥有String类型的data成员，Inner实现了Drop trait来清理data的资源。
Outer结构体包含一个Inner类型的inner成员和一个借用的&'static str类型的borrowed_ref成员。Outer也实现了Drop trait。
当outer超出作用域时，首先调用Outer的析构函数，然后逆序调用Inner的析构函数，释放data的资源。而borrowed_ref由于是借用的静态字符串，不需要在Outer的析构函数中清理。

可能出现的问题及解决办法
- 问题：双重释放
  - 如果不小心将拥有所有权的成员的所有权转移到结构体外部，然后结构体析构函数又尝试释放该资源，就会导致双重释放错误。例如：

struct MyStruct {
    data: String,
}

impl Drop for MyStruct {
    fn drop(&mut self) {
        println!("Dropping MyStruct with data: {}", self.data);
    }
}

fn main() {
    let mut s = MyStruct {
        data: "Hello".to_string(),
    };
    let data_ref = &mut s.data;
    // 将`data`的所有权转移到函数外部
    let moved_data = std::mem::take(data_ref);
    // 这里`moved_data`和`s`都认为自己拥有`data`的所有权，
    // 当`s`析构时会尝试再次释放`data`，导致双重释放错误
}

解决办法：
- 在转移所有权时，确保原所有者不再尝试释放资源。例如，可以通过Option类型来管理所有权，明确资源的当前所有者。

struct MyStruct {
    data: Option<String>,
}

impl Drop for MyStruct {
    fn drop(&mut self) {
        if let Some(ref data) = self.data {
            println!("Dropping MyStruct with data: {}", data);
        }
    }
}

fn main() {
    let mut s = MyStruct {
        data: Some("Hello".to_string()),
    };
    let data_ref = &mut s.data;
    let moved_data = data_ref.take();
    // 此时`s`的`data`变为`None`，不会再尝试释放已转移所有权的资源
}

问题：悬空引用
- 如果在结构体析构前，借用的成员所指向的资源已经被释放，就会产生悬空引用。例如：

struct Inner {
    data: String,
}

struct Outer {
    inner_ref: &Inner,
}

fn main() {
    let inner = Inner {
        data: "Hello".to_string(),
    };
    {
        let outer = Outer {
            inner_ref: &inner,
        };
        // 这里`outer`借用了`inner`，如果`inner`先于`outer`超出作用域，
        // `outer`中的`inner_ref`就会成为悬空引用
    }
}

解决办法：
- 确保借用的资源生命周期足够长，或者使用智能指针（如Rc、Arc）来管理共享资源的生命周期，同时结合Weak指针来避免循环引用导致的内存泄漏。例如：

use std::rc::{Rc, Weak};

struct Inner {
    data: String,
}

struct Outer {
    inner_ref: Weak<Inner>,
}

fn main() {
    let inner = Rc::new(Inner {
        data: "Hello".to_string(),
    });
    let outer = Outer {
        inner_ref: Rc::downgrade(&inner),
    };
    // 使用`Weak`指针避免循环引用，同时可以通过`upgrade`方法获取`Rc`指针
    if let Some(inner) = outer.inner_ref.upgrade() {
        println!("Inner data: {}", inner.data);
    }
}

星途面试题库

面试题：Rust析构函数与所有权系统的交互

知识考点

面试题答案