Rust嵌套循环中使用向量与引用的所有权问题求助

我想用Rust的结构体和向量实现多层父子关系（父->子->孙->曾孙），但遇到了所有权问题：当创建Parent实例并立刻推入向量后，实例的所有权会转移到向量中，后续再尝试给这个Parent添加子项时会报错。如果先完成子项添加再推入向量就没问题，但我觉得这种写法不够直观。我试过用Box<Parent>存入Vec<Box<Parent>>，但因为Parent没实现Copy trait，还是遇到同样的问题。我希望每个结构体实例只保留一份拷贝。

相关代码：

#[derive(Debug)]
#[allow(dead_code)]
struct Parent {
    id: usize,
    children: Vec<Child>,
}

#[derive(Debug)]
#[allow(dead_code)]
struct Child {
    id: usize,
    age: usize,
}

fn main() {
    let mut parents: Vec<Parent> = Vec::new();

    for parent_id in 1..4 {
        let mut p = Parent {
            id: parent_id,
            children: Vec::new(),
        };

        // 如果在这里把Parent推入向量，值会被移动
        // 后续对子项的修改不会作用到向量里的实例
        parents.push(p);

        for child_id in 1..3 {
            let c = Child {
                id: child_id,
                age: child_id + 10,
            };
            p.children.push(c); // 这里会报错，因为p已经被移动了
        }

        // 把push移到这里可以正常运行，但我觉得这么写不太合理
        //parents.push(p);
    }

    println!("{:#?}", parents);
}

错误信息：

error[E0382]: borrow of moved value: `p`
  --> src/main.rs:34:13
   |
19 |         let mut p = Parent {
   |             ----- 因为`p`的类型`Parent`未实现`Copy` trait，所以发生移动
...
27 |         parents.push(p);
   |                      - 值已被移动到此处
...
34 |             p.children.push(c);
   |             ^^^^^^^^^^^^^^^^^^ 值被移动后在此处被借用

方案1：先完成实例构建再推入向量（推荐） #

你觉得这种写法“不舒服”，但其实这是最贴合Rust所有权模型的做法——先把Parent的所有子项（包括孙、曾孙层级）都构建完成，再把它的所有权转移到向量中。这种写法清晰且无额外开销，完全适配多层结构的需求：

#[derive(Debug)]
#[allow(dead_code)]
struct Parent {
    id: usize,
    children: Vec<Child>,
}

#[derive(Debug)]
#[allow(dead_code)]
struct Child {
    id: usize,
    age: usize,
    grandchildren: Vec<Grandchild>,
}

#[derive(Debug)]
#[allow(dead_code)]
struct Grandchild {
    id: usize,
    great_grandchildren: Vec<GreatGrandchild>,
}

#[derive(Debug)]
#[allow(dead_code)]
struct GreatGrandchild {
    id: usize,
}

fn main() {
    let mut parents: Vec<Parent> = Vec::new();

    for parent_id in 1..4 {
        let mut p = Parent {
            id: parent_id,
            children: Vec::new(),
        };

        for child_id in 1..3 {
            let mut child = Child {
                id: child_id,
                age: child_id + 10,
                grandchildren: Vec::new(),
            };

            // 构建孙辈及曾孙辈
            for grandchild_id in 1..2 {
                let mut grandchild = Grandchild {
                    id: grandchild_id,
                    great_grandchildren: Vec::new(),
                };
                grandchild.great_grandchildren.push(GreatGrandchild { id: 1 });
                child.grandchildren.push(grandchild);
            }

            p.children.push(child);
        }

        // 所有层级构建完成后再推入向量
        parents.push(p);
    }

    println!("{:#?}", parents);
}

这种写法逻辑分层明确，每一层都先完成内部结构的构建，再向上层传递所有权，完全符合Rust的设计理念，不会有任何所有权冲突。

方案2：推入向量后获取可变引用修改 #

如果你确实需要先把Parent推入向量再修改子项，可以通过向量的last_mut()方法获取刚推入实例的可变引用，直接操作向量中的数据：

fn main() {
    let mut parents: Vec<Parent> = Vec::new();

    for parent_id in 1..4 {
        let p = Parent {
            id: parent_id,
            children: Vec::new(),
        };

        parents.push(p);

        // 获取向量最后一个元素的可变引用
        if let Some(parent) = parents.last_mut() {
            for child_id in 1..3 {
                let c = Child {
                    id: child_id,
                    age: child_id + 10,
                };
                parent.children.push(c);
            }
        }
    }

    println!("{:#?}", parents);
}

如果知道元素索引（比如刚push的元素索引是parents.len() - 1），也可以用parents.get_mut(parents.len() - 1)获取可变引用。这种方式同样保证每个实例只有一份拷贝，无需提前完成所有子项构建。

为什么Box<Parent>没用？ #

你尝试用Box<Parent>存入向量但仍有问题，是因为Box本身也是所有权类型——当你把Box<Parent>推入向量时，Box的所有权会转移到向量中，原变量同样会失效。方案2同样适用于Vec<Box<Parent>>，只需调整引用获取方式：

fn main() {
    let mut parents: Vec<Box<Parent>> = Vec::new();

    for parent_id in 1..4 {
        let p = Box::new(Parent {
            id: parent_id,
            children: Vec::new(),
        });

        parents.push(p);

        if let Some(parent) = parents.last_mut() {
            for child_id in 1..3 {
                let c = Child {
                    id: child_id,
                    age: child_id + 10,
                };
                parent.children.push(c);
            }
        }
    }

    println!("{:#?}", parents);
}

• 优先选择方案1：先构建完整实例再推入向量，这是最符合Rust风格的写法，逻辑清晰且无额外开销。
• 若必须先推入再修改，用方案2获取可变引用直接操作向量中的实例，同样满足单份拷贝的需求。

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