如何在Rust中正确编写含生命周期依赖成员的Everyone结构体？

你的代码报错的核心原因是：Child借用了栈上Parent实例的name字段，随后你将Parent的所有权转移到Everyone结构体中——这会导致原来的借用失效，因为Parent的内存位置可能因移动发生变化，Rust的借用检查器会阻止这种可能产生悬垂引用的操作。

下面提供几种可行的解决思路：

思路一：调整构造逻辑，让Child直接借用Everyone内部的Parent #

通过给Everyone实现构造方法，先将Parent存入结构体，再从内部的Parent创建Child，确保引用的生命周期与Everyone绑定：

struct Parent {
    name: String,
}

impl Parent {
    fn create_child(&self) -> Child<'_> {
        Child { parent_name: &self.name }
    }
}

struct Child<'a> {
    parent_name: &'a str,
}

struct Everyone<'a> {
    p: Parent,
    c: Child<'a>,
}

impl<'a> Everyone<'a> {
    fn new(name: String) -> Self {
        let mut everyone = Everyone {
            p: Parent { name },
            c: Child { parent_name: "" }, // 临时占位值
        };
        // 借用结构体内部的Parent，引用生命周期与everyone绑定
        everyone.c = everyone.p.create_child();
        everyone
    }
}

fn main() {
    let e = Everyone::new("foo".to_owned());
    println!("Parent: {}, Child's parent: {}", e.p.name, e.c.parent_name);
}

这种方案完全遵循Rust的借用规则，没有额外内存开销，适合Parent和Child生命周期严格绑定的场景。

思路二：让Child持有独立的String（克隆） #

如果不介意少量内存开销，可以让Child直接克隆Parent的name字段，彻底避免借用关系：

struct Parent {
    name: String,
}

impl Parent {
    fn create_child(&self) -> Child {
        Child { parent_name: self.name.clone() }
    }
}

struct Child {
    parent_name: String,
}

struct Everyone {
    p: Parent,
    c: Child,
}

fn main() {
    let p = Parent { name: "foo".to_owned() };
    let c = p.create_child();
    let e = Everyone { p, c };
    println!("Parent: {}, Child's parent: {}", e.p.name, e.c.parent_name);
}

这种写法最简单，不需要处理复杂的生命周期，适合逻辑简单、对内存开销不敏感的场景。

思路三：使用共享所有权（Rc/Arc） #

如果需要Parent和Child独立拥有name的所有权（比如两者生命周期不一致），可以用Rc（单线程）或Arc（多线程）实现共享：

use std::rc::Rc;

struct Parent {
    name: Rc<String>,
}

impl Parent {
    fn create_child(&self) -> Child {
        Child { parent_name: Rc::clone(&self.name) }
    }
}

struct Child {
    parent_name: Rc<String>,
}

struct Everyone {
    p: Parent,
    c: Child,
}

fn main() {
    let p = Parent { name: Rc::new("foo".to_owned()) };
    let c = p.create_child();
    let e = Everyone { p, c };
    println!("Parent: {}, Child's parent: {}", e.p.name, e.c.parent_name);
}

Rc::clone只是增加引用计数，不会复制字符串内容，开销极低，适合需要多个所有者的场景。

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