C++动态n*n矩阵传参至求和函数报错求助

方案1：使用std::vector（推荐） #

C++里处理动态大小的矩阵，首选std::vector——它自带内存管理，传参简单直接，完全支持任意维度的n×n矩阵，还能避免手动内存操作的风险。

示例代码：

#include <iostream>
#include <vector>

// 计算两个n×n矩阵的和，结果存入第三个矩阵（传引用避免拷贝开销）
void sum(const std::vector<std::vector<int>>& mat1, 
         const std::vector<std::vector<int>>& mat2, 
         std::vector<std::vector<int>>& result) {
    int n = mat1.size();
    // 初始化结果矩阵的尺寸
    result.resize(n, std::vector<int>(n));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

int main() {
    int n;
    std::cout << "输入矩阵维度n: ";
    std::cin >> n;

    // 初始化两个输入矩阵
    std::vector<std::vector<int>> mat1(n, std::vector<int>(n));
    std::vector<std::vector<int>> mat2(n, std::vector<int>(n));
    std::vector<std::vector<int>> result;

    std::cout << "输入第一个矩阵:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cin >> mat1[i][j];
        }
    }

    std::cout << "输入第二个矩阵:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cin >> mat2[i][j];
        }
    }

    // 调用求和函数
    sum(mat1, mat2, result);

    // 输出结果
    std::cout << "矩阵和为:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cout << result[i][j] << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

方案2：使用指针传递（兼容C风格） #

如果一定要用原生数组，可以通过传递指向数组的指针，同时把矩阵维度n作为参数传入。注意必须手动管理内存，避免泄漏。

示例代码：

#include <iostream>
#include <cstdlib>

// 接收两个n×n矩阵的指针，返回求和后的矩阵指针
int** sum(int** mat1, int** mat2, int n) {
    // 分配结果矩阵的内存
    int** result = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; ++i) {
        result[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; ++j) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
    return result;
}

int main() {
    int n;
    std::cout << "输入矩阵维度n: ";
    std::cin >> n;

    // 分配第一个矩阵内存
    int** mat1 = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; ++i) {
        mat1[i] = (int*)malloc(n * sizeof(int));
    }

    // 分配第二个矩阵内存
    int** mat2 = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; ++i) {
        mat2[i] = (int*)malloc(n * sizeof(int));
    }

    std::cout << "输入第一个矩阵:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cin >> mat1[i][j];
        }
    }

    std::cout << "输入第二个矩阵:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cin >> mat2[i][j];
        }
    }

    int** result = sum(mat1, mat2, n);

    // 输出结果
    std::cout << "矩阵和为:\n";
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cout << result[i][j] << " ";
        }
        std::cout << "\n";
    }

    // 释放内存，避免泄漏
    for (int i = 0; i < n; ++i) {
        free(mat1[i]);
        free(mat2[i]);
        free(result[i]);
    }
    free(mat1);
    free(mat2);
    free(result);

    return 0;
}

为什么固定维度方案不适用？ #

C++中，原生二维数组的类型和维度强绑定（比如int[2][2]和int[3][3]是完全不同的类型），所以函数参数如果写死固定维度，只能接收对应大小的数组，无法适配动态变化的n值。上面两种方案要么用vector这种动态容器，要么用指针+维度参数的方式，绕过了类型绑定的限制。

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