Rust中实现国际象棋棋盘理想内存布局的优化问询

你当前的实现中，每个Option<Piece>占用2字节，主要是因为Piece结构体包含两个独立枚举（各占1字节），且Option的包装没有充分利用内存空间。实际上，棋盘格子的所有可能状态（空+6种棋子类型×2种颜色）仅13种，完全可以压缩到1字节内。以下是两种高效实现方案：

方案1：单一枚举表示所有状态 #

这是最直观的方式，直接定义包含所有可能状态的枚举，Rust会自动将其优化为1字节大小（变体数量≤256）：

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Square {
    Empty,
    WhitePawn,
    WhiteKnight,
    WhiteBishop,
    WhiteRook,
    WhiteQueen,
    WhiteKing,
    BlackPawn,
    BlackKnight,
    BlackBishop,
    BlackRook,
    BlackQueen,
    BlackKing,
}

#[derive(Debug, Copy, Clone)]
pub struct Board {
    pub squares: [[Square; 8]; 8],
}

这个实现中，每个Square仅占1字节，整个Board结构体大小为8×8=64字节，完全符合内存高效的需求。代码可读性强，无需额外拆分逻辑，直接通过枚举变体判断格子状态即可。

方案2：位打包结构体 #

如果你想保留原有的Colors和PieceTypes枚举，可以通过位运算将颜色和棋子类型打包到一个u8中，同样实现1字节内存占用：

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum PieceTypes {
    Pawn,
    Knight,
    Bishop,
    Rook,
    Queen,
    King,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Colors {
    White,
    Black,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Square(u8);

impl Square {
    // 空格子常量
    pub const EMPTY: Self = Self(0);

    // 从颜色和棋子类型创建Square
    pub fn new(color: Colors, piece_type: PieceTypes) -> Self {
        // 低3位存储棋子类型（1-6对应6种类型，0表示空）
        let type_code = match piece_type {
            PieceTypes::Pawn => 1,
            PieceTypes::Knight => 2,
            PieceTypes::Bishop => 3,
            PieceTypes::Rook => 4,
            PieceTypes::Queen => 5,
            PieceTypes::King => 6,
        };
        // 第4位存储颜色（0=白，8=黑，对应二进制第4位）
        let color_code = match color {
            Colors::White => 0,
            Colors::Black => 8,
        };
        Self(type_code | color_code)
    }

    // 获取格子颜色（空格子返回None）
    pub fn color(&self) -> Option<Colors> {
        if self.0 == 0 {
            None
        } else if (self.0 & 8) == 0 {
            Some(Colors::White)
        } else {
            Some(Colors::Black)
        }
    }

    // 获取棋子类型（空格子返回None）
    pub fn piece_type(&self) -> Option<PieceTypes> {
        match self.0 & 7 { // 提取低3位
            0 => None,
            1 => Some(PieceTypes::Pawn),
            2 => Some(PieceTypes::Knight),
            3 => Some(PieceTypes::Bishop),
            4 => Some(PieceTypes::Rook),
            5 => Some(PieceTypes::Queen),
            6 => Some(PieceTypes::King),
            _ => unreachable!("无效的棋子类型编码"),
        }
    }

    // 判断是否为空格子
    pub fn is_empty(&self) -> bool {
        self.0 == 0
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Board {
    pub squares: [[Square; 8]; 8],
}

该方案通过位运算把颜色和类型信息打包到单个u8中，每个Square仅占1字节，整个Board大小为64字节。通过Square提供的方法可以安全存取状态，兼顾了内存效率和代码封装性。

验证内存占用 #

你可以用std::mem::size_of验证内存大小：

fn main() {
    println!("Square 大小: {} 字节", std::mem::size_of::<Square>());
    println!("Board 大小: {} 字节", std::mem::size_of::<Board>());
}

运行后会输出Square 大小: 1 字节和Board 大小: 64 字节，符合预期。

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