生命游戏：如何高效计数矩阵细胞存活邻居且避免越界检查

看起来你在优化生命游戏的邻居计数逻辑，不想用一堆if-else来处理边界检查——完全理解，那种嵌套的条件判断不仅代码不美观，还容易出错（比如你原来的代码里先访问数组再判断边界，会导致越界访问的未定义行为，这个得先纠正！）

下面给你几种简洁的解决方案，不用写大量条件语句就能搞定边界处理：

方案1：合并边界条件，利用逻辑短路先判断合法性 #

首先要把边界判断放在最前面，确保坐标合法后再访问数组，避免越界。我们可以把四个边界条件合并成一行，利用C语言的逻辑短路特性（前面的条件不满足时，后面的表达式不会执行）：

void Neighbours(int rows, int cols, cell world[rows][cols], int neighbors[rows][cols]) {
    // 遍历每个细胞
    for(int rCell = 0; rCell < rows; rCell++){
        for(int cCell = 0; cCell < cols; cCell++) {
            neighbors[rCell][cCell] = 0;
            // 遍历周围3x3的区域
            for(int surroundR = -1; surroundR <= 1; surroundR++){
                for(int surroundC = -1; surroundC <= 1; surroundC++) {
                    // 计算邻居的坐标
                    int nr = rCell + surroundR;
                    int nc = cCell + surroundC;
                    
                    // 先判断边界合法，再排除自身，最后检查是否存活
                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols 
                        && !(surroundR == 0 && surroundC == 0)
                        && world[nr][nc].status == ALIVE) {
                        neighbors[rCell][cCell]++;
                    }
                }
            }
        }
    }
}

这里把所有条件合并到一个if里，既避免了越界，又不用拆分多个if-else，代码更紧凑。

方案2：限制循环范围，从根源避免越界检查 #

另一种更优雅的思路是：直接计算每个细胞的合法邻居范围，只遍历这个范围内的细胞，这样循环内部根本不需要边界判断。

比如，对于细胞(rCell, cCell)：

• 邻居的行范围是max(0, rCell-1)到min(rows-1, rCell+1)
• 邻居的列范围是max(0, cCell-1)到min(cols-1, cCell+1)

然后遍历这个范围，只需要排除细胞自身即可：

void Neighbours(int rows, int cols, cell world[rows][cols], int neighbors[rows][cols]) {
    for(int rCell = 0; rCell < rows; rCell++){
        for(int cCell = 0; cCell < cols; cCell++) {
            neighbors[rCell][cCell] = 0;
            
            // 计算合法的邻居行/列范围
            int startR = (rCell > 0) ? rCell - 1 : 0;
            int endR = (rCell < rows - 1) ? rCell + 1 : rows - 1;
            int startC = (cCell > 0) ? cCell - 1 : 0;
            int endC = (cCell < cols - 1) ? cCell + 1 : cols - 1;
            
            // 只遍历合法范围内的细胞
            for(int nr = startR; nr <= endR; nr++){
                for(int nc = startC; nc <= endC; nc++) {
                    // 跳过细胞自身
                    if(nr == rCell && nc == cCell) {
                        continue;
                    }
                    // 直接检查存活状态，因为坐标肯定合法
                    if(world[nr][nc].status == ALIVE) {
                        neighbors[rCell][cCell]++;
                    }
                }
            }
        }
    }
}

这种方法的代码可读性更高，循环逻辑更清晰，完全没有冗余的边界判断，也彻底避免了越界风险，个人更推荐这种方案。

方案3：模运算（适用于环形拓扑场景） #

如果你的需求是环形网格（比如边界细胞的邻居是对面的细胞，类似 torus 拓扑），那可以用模运算来自动处理边界，连条件判断都不需要：

void Neighbours(int rows, int cols, cell world[rows][cols], int neighbors[rows][cols]) {
    for(int rCell = 0; rCell < rows; rCell++){
        for(int cCell = 0; cCell < cols; cCell++) {
            neighbors[rCell][cCell] = 0;
            for(int surroundR = -1; surroundR <= 1; surroundR++){
                for(int surroundC = -1; surroundC <= 1; surroundC++) {
                    if(surroundR == 0 && surroundC == 0) {
                        continue;
                    }
                    // 用模运算处理环形边界，负数加rows/cols后取模避免负索引
                    int nr = (rCell + surroundR + rows) % rows;
                    int nc = (cCell + surroundC + cols) % cols;
                    if(world[nr][nc].status == ALIVE) {
                        neighbors[rCell][cCell]++;
                    }
                }
            }
        }
    }
}

注意这个方案只适用于环形拓扑的场景，如果边界外的细胞视为死亡，就不要用这个方法。

最后再提一句：你原来的代码里先访问field[rCell - surroundR][cCell - surroundC].status再判断边界，这是非常危险的——越界访问数组属于未定义行为，可能导致程序崩溃或者奇怪的bug，一定要先判断坐标合法性再访问数组元素！

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