如何在C++中实现无参数限制的灵活矩阵填充与显示？

问题背景 #

刚开始学习矩阵，希望在C中实现矩阵的填充与显示功能时，让函数保持高度灵活性，无需在参数中固定矩阵的大小限制。最初尝试的代码无法运行，因为C对二维数组作为函数参数有语法限制；改用固定100×100的矩阵后代码可运行，但会产生大量未使用的单元格，希望找到无需声明固定大小的实现方式。

原错误代码（无法运行） #

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <ctime>

using namespace std;

int num1,num2,maxx;

void fillarray(int array1[][],int nummax)
{
 int x=0;
 srand(time(0));
 for (x;x<num1;x++)
 {
     for (int y=0; y<num2;y++)
     array1[x][y]=rand()%nummax;
 }
}

void showarray(int array1[][])
{
int x=0;
for (x;x<num1;x++)
{
    for (int y=0; y<num2; y++)
        cout << array1[x][y]<<"\t";

        cout << "\n"<<endl;
}
}

int main()
{
    cout << "Input the number of lines in the mattrice: ";
    cin >> num1;
    cout << "Input the number of columns in the mattrice: ";
    cin >> num2;
    cout << "Input the maximum value in the mattrice: ";
    cin >> maxx;

    int matrice[num1][num2];

    fillarray(matrice,maxx);
    cout << "The matrix created: \n\n\n";
    showarray(matrice);

return 0;
}

原可行但浪费空间的代码 #

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <ctime>

using namespace std;

int num1,num2,maxx;

void fillarray(int array1[100][100],int nummax)
{
 int x=0;
 srand(time(0));
 for (x;x<num1;x++)
 {
     for (int y=0; y<num2;y++)
     array1[x][y]=rand()%nummax;
 }
}

void showarray(int array1[100][100])
{
int x=0;
for (x;x<num1;x++)
{
    for (int y=0; y<num2; y++)
        cout << array1[x][y]<<"\t";

        cout << "\n"<<endl;
}
}

int main()
{
    cout << "Input the number of lines in the mattrice: ";
    cin >> num1;
    cout << "Input the number of columns in the mattrice: ";
    cin >> num2;
    cout << "Input the maximum value in the mattrice: ";
    cin >> maxx;

    int matrice[100][100];

    fillarray(matrice,maxx);
    cout << "The matrix created: \n\n\n";
    showarray(matrice);

return 0;
}

问题分析 #

1. 二维数组参数限制：C++中，二维数组作为函数参数时，必须指定第二维的大小（比如int array1[][100]），因为编译器需要通过第二维的大小计算数组元素的内存偏移地址，无法直接写int array1[][]。
2. 变量长度数组（VLA）不兼容：原错误代码中的int matrice[num1][num2]属于变量长度数组，这是C99标准的特性，标准C++并不支持，部分编译器（如GCC）可能允许但移植性差。
3. 全局变量耦合性高：使用全局变量num1、num2来控制循环范围，会导致函数依赖全局状态，代码模块化差。

解决方案 #

方案1：使用模板函数（编译时推导矩阵大小）

利用C++模板的类型推导特性，让编译器自动获取矩阵的行数和列数，无需手动指定参数中的大小限制。同时去掉全局变量，将行列数作为参数传入函数：

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

// 模板函数，自动推导矩阵的行数和列数
template <size_t Rows, size_t Cols>
void fillarray(int (&array1)[Rows][Cols], int nummax, int actualRows, int actualCols)
{
    srand(time(nullptr));
    for (int x = 0; x < actualRows; x++)
    {
        for (int y = 0; y < actualCols; y++)
        {
            array1[x][y] = rand() % nummax;
        }
    }
}

template <size_t Rows, size_t Cols>
void showarray(int (&array1)[Rows][Cols], int actualRows, int actualCols)
{
    for (int x = 0; x < actualRows; x++)
    {
        for (int y = 0; y < actualCols; y++)
        {
            cout << array1[x][y] << "\t";
        }
        cout << "\n\n";
    }
}

int main()
{
    const size_t MAX_ROWS = 100;
    const size_t MAX_COLS = 100;
    int num1, num2, maxx;

    cout << "Input the number of lines in the matrix: ";
    cin >> num1;
    cout << "Input the number of columns in the matrix: ";
    cin >> num2;
    cout << "Input the maximum value in the matrix: ";
    cin >> maxx;

    // 声明最大尺寸的数组，但只使用用户指定的行列数
    int matrice[MAX_ROWS][MAX_COLS];

    fillarray(matrice, maxx, num1, num2);
    cout << "The matrix created: \n\n\n";
    showarray(matrice, num1, num2);

    return 0;
}

方案2：使用vector<vector<int>>（完全动态，推荐）

C的标准容器vector支持动态大小，vector<vector<int>>可以实现完全灵活的二维矩阵，无需固定大小限制，函数参数直接传递容器的引用即可，这是C中处理动态二维数组的推荐方式：

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>

using namespace std;

// 填充动态矩阵
void fillarray(vector<vector<int>>& matrix, int nummax)
{
    srand(time(nullptr));
    for (auto& row : matrix)
    {
        for (int& elem : row)
        {
            elem = rand() % nummax;
        }
    }
}

// 显示动态矩阵
void showarray(const vector<vector<int>>& matrix)
{
    for (const auto& row : matrix)
    {
        for (int elem : row)
        {
            cout << elem << "\t";
        }
        cout << "\n\n";
    }
}

int main()
{
    int num1, num2, maxx;

    cout << "Input the number of lines in the matrix: ";
    cin >> num1;
    cout << "Input the number of columns in the matrix: ";
    cin >> num2;
    cout << "Input the maximum value in the matrix: ";
    cin >> maxx;

    // 创建动态大小的矩阵，直接初始化用户指定的行列数
    vector<vector<int>> matrice(num1, vector<int>(num2));

    fillarray(matrice, maxx);
    cout << "The matrix created: \n\n\n";
    showarray(matrice);

    return 0;
}

方案对比 #

• 模板函数：适合需要使用静态数组的场景，需要预先指定最大大小，但可以避免动态内存管理的复杂度。
• vector容器：完全动态，无需预先指定大小，内存自动管理，代码模块化更强，更符合C++的现代编程风格，是更推荐的方案。

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