Rust中如何在结构体中同时持有Context及关联的Thing对象？

看起来你碰到了Rust里经典的"自引用结构体"难题——想让Friend同时持有Context和从它创建的Thing，但静态借用检查器直接给你亮出了红牌。别担心，我们有几种安全的解决方案，根据你的实际场景选就行：

方案1：直接复制数据（最简单，优先考虑） #

如果Thing里的字段都是Copy类型（比如你的例子里的i32），那完全可以把引用换成值，彻底摆脱生命周期依赖。修改后的代码如下：

#[derive(Debug)]
struct Thing {
    aa: i32,
    bb: i32,
}

#[derive(Debug)]
struct Context {
    // 假设实际业务中这里是你要引用的数据
    data: i32,
}

impl Context {
    fn init() -> Self { Context { data: 9 } }
    fn thing(&self) -> Thing {
        // 直接从Context复制数据到Thing，不再需要借用
        Thing { aa: self.data, bb: 10 }
    }
}

struct Friend {
    context: Context,
    thing: Thing,
}

impl Friend {
    fn new() -> Self {
        let context = Context::init();
        let thing = context.thing();
        Self { context, thing }
    }
}

fn main() {
    let boy = Friend::new();
    println!("value is {}", boy.thing.bb);
}

这种方案没有任何额外开销，代码也最简洁，只要你的数据允许复制，这就是最优解。

方案2：用共享所有权（Arc）解决关联问题 #

如果Thing需要和Context保持动态关联（比如数据可能被修改，或者数据太大不适合复制），可以用Arc（原子引用计数）来共享Context的所有权。这样Friend和Thing都持有Arc<Context>的副本，不存在借用冲突：

use std::sync::Arc;

#[derive(Debug)]
struct Thing {
    // 持有Context的共享所有权，不再依赖生命周期
    context: Arc<Context>,
    bb: i32,
}

#[derive(Debug)]
struct Context {
    data: i32,
}

impl Context {
    fn init() -> Arc<Self> { Arc::new(Context { data: 9 }) }
    // 接收Arc<Self>作为self，直接传递所有权给Thing
    fn thing(self: Arc<Self>) -> Thing {
        Thing { context: self, bb: 10 }
    }
}

struct Friend {
    context: Arc<Context>,
    thing: Thing,
}

impl Friend {
    fn new() -> Self {
        let context = Context::init();
        // 克隆Arc只是增加引用计数，不会复制底层数据
        let thing = context.clone().thing();
        Self { context, thing }
    }
}

fn main() {
    let boy = Friend::new();
    println!("Context data: {}", boy.context.data);
    println!("Thing value: {}", boy.thing.bb);
}

Arc是线程安全的，如果你不需要线程安全，也可以用Rc（非原子版本，开销更小）。

方案3：自引用结构体（复杂，仅必要时使用） #

如果必须保持Thing对Context的直接借用，且不想用上面两种方案，可以借助第三方库（比如ouroboros）来实现安全的自引用结构体。这种方案需要遵循库的规则，代码复杂度较高：

首先在Cargo.toml添加依赖：

ouroboros = "0.15"

然后修改代码：

use ouroboros::self_referencing;

#[derive(Debug)]
struct Thing<'a> {
    aa: &'a i32,
    bb: &'static i32,
}

#[derive(Debug)]
struct Context {
    data: i32,
}

impl Context {
    fn init() -> Self { Context { data: 9 } }
    fn thing<'a>(&'a self) -> Thing<'a> {
        Thing { aa: &self.data, bb: &10 }
    }
}

// 用ouroboros的宏定义自引用结构体
#[self_referencing]
struct Friend {
    context: Context,
    // 标记该字段借用context
    #[borrows(context)]
    thing: Thing<'this>,
}

impl Friend {
    fn new() -> Self {
        FriendBuilder {
            context: Context::init(),
            // 构建thing的闭包，接收context的引用
            thing_builder: |context| context.thing(),
        }.build()
    }
}

fn main() {
    let boy = Friend::new();
    // 必须用with_thing方法访问thing，不能直接持有引用
    boy.with_thing(|thing| {
        println!("value is {}", thing.bb);
    });
}

为什么原始代码会报错？ #

简单来说，Rust的静态借用检查器不允许结构体同时拥有一个值和对该值的引用：

1. thing是从context借用的，它的生命周期和context绑定
2. 你试图把context（拥有权）和thing（借用context）一起放进Friend返回
3. 检查器无法静态验证context被移动到Friend后，thing的引用依然有效——它只会看到一个局部变量被借用后又被移动，直接判定为悬垂引用风险。

内容的提问来源于stack exchange，提问作者Pablo Tato Ramos