如何将Rust扫雷的insert_mines方法改为使用&mut self？

原方法获取所有权是否合理？ #

直接获取self所有权的实现并不合理。扫雷的Field是需要被后续操作（比如点击单元格、展示棋盘）反复使用的核心数据结构，转移所有权意味着调用insert_mines后原Field实例就无法再被访问，完全不符合游戏的使用逻辑。这种设计通常是对Rust所有权模型理解不到位导致的，正确做法应该是通过可变引用修改内部状态。

如何正确改写为&mut self版本？ #

假设你的核心类型定义大致如下：

#[derive(Clone, Copy)]
enum Cell {
    Empty(u8), // 存储周围地雷数量
    Mine,
    Hidden,
}

struct Field(Vec<Vec<Cell>>);

下面是具体的改写步骤：

1. 修正方法签名 #

将方法改为接收&mut self，同时处理地雷数量超出棋盘总单元格数的边界情况：

impl Field {
    fn new(width: u16, height: u16) -> Self {
        let cells = vec![vec![Cell::Hidden; width as usize]; height as usize];
        Field(cells)
    }

    fn insert_mines(&mut self, number_of_mines: u16) -> Result<(), ()> {
        let total_cells = (self.0.len() * self.0[0].len()) as u16;
        if number_of_mines > total_cells {
            return Err(()); // 地雷数量超出上限，返回错误
        }

        self.place_mines(number_of_mines);
        self.calculate_neighbor_counts();
        Ok(())
    }
}

2. 安全插入地雷（避免移出self） #

不要尝试将self.0扁平化后移出，直接通过可变引用遍历并修改单元格。借助rand库生成随机位置，确保不重复放置地雷：

// 需要在Cargo.toml添加依赖：rand = "0.8"
use rand::Rng;

impl Field {
    fn place_mines(&mut self, number_of_mines: u16) {
        let mut rng = rand::thread_rng();
        let height = self.0.len();
        let width = self.0[0].len();
        let mut placed = 0;

        while placed < number_of_mines {
            let y = rng.gen_range(0..height);
            let x = rng.gen_range(0..width);

            // 只在未被修改的隐藏单元格放置地雷，避免重复
            if matches!(self.0[y][x], Cell::Hidden) {
                self.0[y][x] = Cell::Mine;
                placed += 1;
            }
        }
    }
}

3. 计算周围地雷数量 #

同样通过可变引用遍历非地雷单元格，统计周围8个方向的地雷数：

impl Field {
    fn calculate_neighbor_counts(&mut self) {
        let height = self.0.len() as i32;
        let width = self.0[0].len() as i32;

        for y in 0..height {
            for x in 0..width {
                let cell = &mut self.0[y as usize][x as usize];
                if matches!(cell, Cell::Mine) {
                    continue; // 跳过地雷单元格
                }

                let mut count = 0;
                // 遍历8个方向的邻居
                for dy in -1..=1 {
                    for dx in -1..=1 {
                        if dy == 0 && dx == 0 {
                            continue; // 跳过自身
                        }
                        let ny = y + dy;
                        let nx = x + dx;
                        // 检查邻居坐标是否在棋盘范围内
                        if ny >= 0 && ny < height && nx >= 0 && nx < width {
                            if matches!(self.0[ny as usize][nx as usize], Cell::Mine) {
                                count += 1;
                            }
                        }
                    }
                }

                *cell = Cell::Empty(count);
            }
        }
    }
}

针对你遇到的错误的解决方案 #

• 类型不匹配：确保new函数返回的是Field实例，内部是Vec<Vec<Cell>>，不要混入任何引用类型；
• 无法移出self：不要尝试将self.0从可变引用中移出，直接通过self.0[y][x]的方式访问和修改单元格；
• 引用转原值错误：永远不要试图将Vec<Vec<&mut Cell>>转回Vec<Vec<Cell>>，直接在原二维向量上修改即可，不需要生成引用集合。

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