Rust循环if语句内实例化对象的所有权问题求解

我正在尝试解析一段包含Point（点）和Polygon（多边形）信息的多行字符串，但遇到了Rust的所有权问题。在C#或C++里，我可以先声明变量，之后在特定位置实例化再后续使用，但在Rust里这么做会触发所有权错误，请问该怎么处理？

问题代码 #

fn main() {
    // Point struct
    struct Point {
        x: f64,
        y: f64,
    }

    // Polygon struct that has points
    struct Polygon {
        points: Vec<Point>,
    }

    // Implement the Polygon struct
    impl Polygon {
        fn new() -> Self {
            Self { points: Vec::new() }
        }
    }

    // Surface struct that has polygons
    struct Surface {
        polygons: Vec<Polygon>,
    }

    // Implement the Surface struct
    impl Surface {
        fn new() -> Self {
            Self { polygons: Vec::new() }
        }
    }

    // string polygons
    let strs = "
    SB
        PB
            PT 350 130
            PT 350 170
            PT 450 170
        PE 
        PB
            PT 370 150
            PT 370 160
            PT 430 160
        PE
    SE";

    let mut surface = Surface::new();
    let mut poly:Polygon = Polygon::new();

    let lines: Vec<&str> = strs.lines().collect();
    for line in lines.iter().map(|s| s.trim()) {
        
        if line == "SB" {
            surface = Surface::new();
        } else if line == "PB" {
            poly = Polygon::new();
            surface.polygons.push(poly);
        } else if line.starts_with("PT") {
            let mut parts = line.split_whitespace();
            parts.next(); // skip "PT"
            let x: f64 = parts.next().unwrap().parse().unwrap();
            let y: f64 = parts.next().unwrap().parse().unwrap();
            let pt = Point { x, y };

            poly.points.push(pt); // <-- Error
            // surface.polygons.last_mut().unwrap().points.push(pt); // <-- OK
        }
    }

    // Print the Surface polygons points
    for poly in surface.polygons.iter() {
        println!("PB");
        for point in poly.points.iter() {
            println!("\tx: {}, y: {}", point.x, point.y);
        }
        println!("PE");
    }
}

错误信息 #

error[E0382]: borrow of moved value: `poly`
  --> src/main.rs:65:13
   |
48 |     let mut poly:Polygon = Polygon::new();
   |         -------- move occurs because `poly` has type `Polygon`, which does not implement the `Copy` trait
...
57 |             surface.polygons.push(poly);
   |                                   ---- value moved here, in previous iteration of loop
...
65 |             poly.points.push(pt); // <-- Error
   |             ^^^^^^^^^^^^^^^^^^^^ value borrowed here after move

问题根源 #

当执行surface.polygons.push(poly)时，poly的所有权已经被转移到surface的polygons向量中，原poly变量不再拥有该值的所有权，自然无法再对其进行修改。这是Rust所有权规则的核心：一个值同一时间只能有一个所有者。

解决方法 #

方案1：直接操作向量中的最后一个元素 #

你注释掉的代码就是正确思路——直接通过surface操作内部的多边形实例，同时可以去掉全局的poly变量避免混淆：

fn main() {
    // 结构体定义部分保持不变

    let strs = "
    SB
        PB
            PT 350 130
            PT 350 170
            PT 450 170
        PE 
        PB
            PT 370 150
            PT 370 160
            PT 430 160
        PE
    SE";

    let mut surface = Surface::new();

    let lines: Vec<&str> = strs.lines().collect();
    for line in lines.iter().map(|s| s.trim()) {
        
        if line == "SB" {
            surface = Surface::new();
        } else if line == "PB" {
            surface.polygons.push(Polygon::new());
        } else if line.starts_with("PT") {
            let mut parts = line.split_whitespace();
            parts.next(); // 跳过"PT"
            let x: f64 = parts.next().unwrap().parse().unwrap();
            let y: f64 = parts.next().unwrap().parse().unwrap();
            let pt = Point { x, y };

            // 直接获取向量最后一个可变引用并添加点
            surface.polygons.last_mut().unwrap().points.push(pt);
        }
    }

    // 打印部分保持不变
}

方案2：用Option管理当前多边形的可变引用 #

如果需要更清晰的变量名，可以用Option临时持有当前活跃的多边形引用，同时在PE分支重置引用避免无效操作：

fn main() {
    // 结构体定义部分保持不变

    let strs = "
    SB
        PB
            PT 350 130
            PT 350 170
            PT 450 170
        PE 
        PB
            PT 370 150
            PT 370 160
            PT 430 160
        PE
    SE";

    let mut surface = Surface::new();
    let mut current_poly: Option<&mut Polygon> = None;

    let lines: Vec<&str> = strs.lines().collect();
    for line in lines.iter().map(|s| s.trim()) {
        
        if line == "SB" {
            surface = Surface::new();
            current_poly = None;
        } else if line == "PB" {
            surface.polygons.push(Polygon::new());
            current_poly = surface.polygons.last_mut();
        } else if line.starts_with("PT") {
            let mut parts = line.split_whitespace();
            parts.next();
            let x: f64 = parts.next().unwrap().parse().unwrap();
            let y: f64 = parts.next().unwrap().parse().unwrap();
            let pt = Point { x, y };

            if let Some(poly) = &mut current_poly {
                (*poly).points.push(pt);
            }
        } else if line == "PE" {
            current_poly = None;
        }
    }

    // 打印部分保持不变
}

关键思路 #

抛弃C#/C++提前声明变量的习惯，严格遵循Rust所有权规则：

• 值被转移到容器（如Vec）后，原变量立即失效
• 修改容器内的值，必须通过容器提供的可变引用操作
• 用Option管理可能存在的可变引用，避免空指针风险

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