Rust所有权概念困惑：请求用指定结构体解释引用所有权路径规则

先明确核心：所有权路径就是从根变量到嵌套数据的访问链（比如outer.inner里，outer→inner就是一条路径）。Rust的借用规则会通过这条路径确保内存安全——只要路径上某一环被引用，整个路径的访问都会受限。

先定义你要求的结构体：

#[derive(Debug)]
struct InnerData {
    value: i32,
}

#[derive(Debug)]
struct OuterData {
    inner: InnerData,
}

1. 无引用时的所有权自由操作 #

没有引用干扰时，所有权可以自由转移、数据可以随意修改：

fn main() {
    let mut outer = OuterData {
        inner: InnerData { value: 42 },
    };

    // 直接修改嵌套的InnerData，完全没问题
    outer.inner.value += 8;
    println!("修改后: {:?}", outer);

    // 把OuterData的所有权转移给another_outer
    let another_outer = outer;
    // println!("{:?}", outer); // 这里会报错，outer的所有权已经转走了
    println!("转移后another_outer: {:?}", another_outer);
}

2. 不可变引用锁定整个路径 #

只要获取了路径上某一环的不可变引用，整个路径都只能做不可变操作，不能修改或获取可变引用：

fn main() {
    let mut outer = OuterData {
        inner: InnerData { value: 42 },
    };

    // 拿到InnerData的不可变引用
    let inner_ref = &outer.inner;
    println!("当前inner值: {}", inner_ref.value);

    // 下面两行都会报错——因为inner_ref锁定了整个outer→inner路径
    // outer.inner.value += 8;
    // let outer_mut_ref = &mut outer;

    // 等inner_ref失效后（比如手动drop或离开作用域），才能恢复操作
    drop(inner_ref);
    outer.inner.value += 8;
    println!("解锁后修改: {:?}", outer);
}

3. 可变引用完全独占路径 #

可变引用的限制更严格，它会完全霸占整个所有权路径，在它存在期间，原变量和路径上的任何部分都不能被访问：

fn main() {
    let mut outer = OuterData {
        inner: InnerData { value: 42 },
    };

    // 拿到OuterData的可变引用
    let outer_mut_ref = &mut outer;
    // 通过可变引用修改内部数据是允许的
    outer_mut_ref.inner.value += 8;
    println!("通过可变引用修改: {:?}", outer_mut_ref);

    // 下面两行都会报错——outer_mut_ref独占了整个路径
    // println!("{:?}", outer);
    // let inner_ref = &outer.inner;

    // 可变引用失效后，原变量恢复可用
    drop(outer_mut_ref);
    println!("可变引用释放后: {:?}", outer);
}

4. 嵌套引用的路径冲突 #

只要两条引用的路径有重叠，Rust就会阻止冲突的借用，不管引用是从外层还是内层获取的：

fn main() {
    let mut outer = OuterData {
        inner: InnerData { value: 42 },
    };

    // 先拿inner的不可变引用，再拿outer的可变引用——报错
    let inner_ref = &outer.inner;
    // let outer_mut_ref = &mut outer;

    // 反过来，先拿outer的可变引用，再拿inner的不可变引用——同样报错
    let outer_mut_ref = &mut outer;
    // let inner_ref = &outer.inner;
}

总结 #

这些示例的核心就是Rust通过所有权路径执行借用规则：任何引用都会锁定它所在的整个访问链，避免数据竞争或悬垂引用。你可以把路径想象成一根绳子，只要绳子上某一段被抓住（引用），整根绳子就不能被以冲突的方式使用。

内容的提问来源于stack exchange，提问作者openyourmind