C++二维数组操作问题：输入读取与循环逻辑修复求助

1. 网格数据读取错误 #

当前代码用嵌套循环读取MAX×MAX个整数，但示例输入中网格是每行连续的数字字符串（比如1234代表4个数字1、2、3、4），且仅需读取n×n个数字，而非MAX×MAX。

修复：

• 读取n行字符串，每行字符串长度为n，逐个字符转换为整数存入网格。
• 循环范围改为i < n和j < n，而非MAX。

2. n的合法性判断错误 #

原代码if (n < 0 && n > 9)逻辑矛盾，永远为假，无法过滤非法输入；且未处理终止条件（输入0退出）。

修复：

• 改为if (n < 1 || n > 9)，如果n不在1-9范围内则跳过当前用例；输入n=0时直接终止循环。

3. 输出格式错误 #

原代码每个数字后都换行，且输出MAX×MAX个元素，不符合要求（应每行输出n个数字，共n行）。

修复：

• 输出时循环i < n和j < n，每行内的数字连续输出，每行结束后换行。

4. 转置函数逻辑错误 #

原转置函数中赋值顺序错误导致数据丢失，且j的起始索引错误（应从0开始而非1）。

修复：

• 修正赋值顺序：先保存grid[i][j]到temp，再将grid[j][i]赋值给grid[i][j]，最后把temp赋值给grid[j][i]。
• j的循环起始改为0，范围j < i。

5. 行/列操作的索引转换问题 #

示例输入中的row 1 2是1-based索引，但函数使用0-based索引，直接传入会导致错误。

修复：

• 读取a和b后，先减1转换为0-based索引，再传入swap函数。

#include <iostream>
#include <string>
#include <cctype>
#include <limits>

using namespace std;
const size_t MAX = 9;

void swap_rows(int grid[][MAX], size_t a, size_t b, size_t size);
void swap_columns(int grid[][MAX], size_t a, size_t b, size_t size);
void increment_grid(int grid[][MAX], size_t size);
void decrement_grid(int grid[][MAX], size_t size);
void transpose_grid(int grid[][MAX], size_t size);

int main() {
    int case_num = 1;
    int grid[MAX][MAX];
    int n;
    int m;
    string op;

    do {
        cin >> n;
        if (n == 0) break; // 输入0终止程序
        if (n < 1 || n > 9) {
            cerr << "Invalid grid size, must be 1-9" << endl;
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            continue;
        }

        // 读取n行网格数据，每行是连续的数字字符串
        for (size_t i = 0; i < n; i++) {
            string row_str;
            cin >> row_str;
            for (size_t j = 0; j < n; j++) {
                if (isdigit(row_str[j])) {
                    grid[i][j] = row_str[j] - '0';
                } else {
                    cerr << "Invalid grid character" << endl;
                    grid[i][j] = 0;
                }
            }
        }

        cin >> m;
        for (int i = 0; i < m; i++) {
            cin >> op;
            if (op == "row") {
                int a, b;
                cin >> a >> b;
                swap_rows(grid, a-1, b-1, n);
            } else if (op == "col") {
                int a, b;
                cin >> a >> b;
                swap_columns(grid, a-1, b-1, n);
            } else if (op == "inc") {
                increment_grid(grid, n);
            } else if (op == "dec") {
                decrement_grid(grid, n);
            } else if (op == "transpose") {
                transpose_grid(grid, n);
            }
        }

        // 输出结果
        cout << "Case #" << case_num << endl;
        case_num++;
        for (size_t i = 0; i < n; i++) {
            for (size_t j = 0; j < n; j++) {
                cout << grid[i][j];
            }
            cout << '\n';
        }
        cout << endl;

    } while (cin.good());

    return 0;
}

void swap_rows(int grid[][MAX], size_t a, size_t b, size_t size) {
    if (a >= size || b >= size) return;
    int temp;
    for (size_t col = 0; col < size; col++) {
        temp = grid[a][col];
        grid[a][col] = grid[b][col];
        grid[b][col] = temp;
    }
}

void swap_columns(int grid[][MAX], size_t a, size_t b, size_t size) {
    if (a >= size || b >= size) return;
    int temp;
    for (size_t row = 0; row < size; row++) {
        temp = grid[row][a];
        grid[row][a] = grid[row][b];
        grid[row][b] = temp;
    }
}

void increment_grid(int grid[][MAX], size_t size) {
    for (size_t i = 0; i < size; i++) {
        for (size_t j = 0; j < size; j++) {
            grid[i][j] = (grid[i][j] + 1) % 10;
        }
    }
}

void decrement_grid(int grid[][MAX], size_t size) {
    for (size_t i = 0; i < size; i++) {
        for (size_t j = 0; j < size; j++) {
            grid[i][j] = (grid[i][j] - 1 + 10) % 10;
        }
    }
}

void transpose_grid(int grid[][MAX], size_t size) {
    int temp;
    for (size_t i = 1; i < size; i++) {
        for (size_t j = 0; j < i; j++) {
            temp = grid[i][j];
            grid[i][j] = grid[j][i];
            grid[j][i] = temp;
        }
    }
}

用你提供的示例输入测试，第一个case转置4×4网格后输出：

Case #1
1515
2626
3737
4848

第二个case交换行1和2、递增后输出：

Case #2
111
111
111

完全符合预期。

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