输入二维数组的大小

在c++中，不能使用可变长度数组。也就是说，不能将输入的整数用作数组的大小，如下所示:

std::cin >> x;
int array[x];

(这将在gcc中工作，但它是一个不可移植的扩展)

当然，也可以做类似的事情。允许您拥有动态大小数组的语言特性是new[]的动态分配。你可以这样做:

std::cin >> x;
int* array = new int[x];

但是注意，这里的array是而不是数组类型。它是指针类型。如果你想动态分配一个二维数组，你必须这样做:

std::cin >> x >> y;
int** array = new int*[x]; // First allocate an array of pointers
for (int i = 0; i < x; i++) {
  array[i] = new int[y]; // Allocate each row of the 2D array
}

但是，这仍然不是数组类型。它现在是一个int**，或"指针指向指针int"。如果要将其传递给函数，则需要将函数的参数设置为int**。例如:

void func(int**);
func(array);

那太好了。然而，您几乎总是需要知道函数内部数组的维数。你怎么能这么做?只需将它们作为额外参数传递即可!

void func(int**, int, int);
func(array, x, y);

这当然是一种方法，但肯定不是c++惯用的方法。它有安全问题，因为它很容易忘记delete一切。您必须手动管理内存分配。您必须这样做以避免内存泄漏:

for (int i = 0; i < x; i++) {
  delete[] array[i];
}
delete[] array;

所以忘记我刚才告诉你的一切。使用标准库容器。您可以轻松地使用std::vector，而不必担心传递尺寸:

void func(std::vector<std::vector<int>>);
std::cin >> x >> y;
std::vector<std::vector<int>> vec(x, std::vector<int>(y));
func(vec);

如果你最终要处理数组类型而不是动态分配数组，那么你可以通过定义一个接受数组引用的模板函数来获得数组的维度:

template <int N, int M>
void func(int (&array)[N][M]);

该函数将为传递给它的所有不同大小的数组实例化。模板参数(数组的尺寸)必须在编译时已知。

我编写了一个小程序:

#include <iostream>
using namespace std;
void fun(int tab[][6], int first)
{}
int main(int argc, char *argv[])
{
    int tab[5][6];
    fun(tab, 5);
    return 0;
}

在函数定义中，必须输入第二个索引的大小。列数作为参数传递。

我猜来自'int'您已遵循验证问题的建议，并且您正在使用std::vector

这个函数返回一个"数组"的列数(如果有问题则返回0)。

int num_column(const std::vector<std::vector<int> > & data){
    if(data.size() == 0){
        std::cout << "There is no row" << std::endl;
        return 0;
    }
    int first_col_size = data[0].size();
    for(auto row : data) {
        if(row.size() != first_col_size){
            std::cout << "All the columns don't have the same size" << std::endl;
            return 0;
        }
    }
    return first_col_size;   
}

如果你使用的是c风格的数组，你可能想在形参中做一个引用:

int (&array)[2][2]; // reference to 2-dimensional array

这是你要找的吗?

int* generate2DArray(int rowSize, int colSize)
{
    int* array2D = new int[rowSize, colSize];
    return array2D;
}

示例…

#include <iostream>
#include <stdio.h>
int* generate2DArray(int rowSize, int colSize);
int random(int min, int max);
int main()
{
    using namespace std;
    int row, col;
    cout << "Enter row, then colums:";
    cin >> row >> col;
    //fill array and display
    int *ptr = generate2DArray(row, col);
    for(int i=0; i<row; ++i)
        for(int j=0; j<col; ++j)
        {
            ptr[i,j] = random(-50,50);
            printf("[%i][%i]: %in", i, j, ptr[i,j]);
        }
    return 0;
}

int* generate2DArray(int rowSize, int colSize)
{
    int* array2D = new int[rowSize, colSize];
    return array2D;
}
int random(int min, int max)
{
    return (rand() % (max+1)) + min;
}

不是访问p[i][j]，而是访问p[i*b + j] -这实际上是编译器为您做的，因为int[a][b]在内存中被平化为a*b大小的数组

同样，你可以把这个函数的原型改成"void gameDisplay(gameCell p[]，int a,int b)"

固定代码:

void gameDisplay(gameCell p[],int a, int b) {
         for(int i=0;i<a;i++) {
                for(int j=0;j<b;j++) {
                         if(p[i*a +j].getStat()==closed)cout<<"C ";
                         if(p[i*a +j].getStat()==secure)cout<<"S ";
                         if(p[i*a +j].getBomb()==true&&p[i][j].getStat()==open)cout<<"% ";
                         if(p[i*a +j].getBomb()==false&&p[i][j].getStat()==open) {
                                 if(p[i*a +j].getNum()==0)cout<<"0 ";
                                 else cout<<p[i*a +j].getNum()<<" ";
                         }
                 cout<<endl;
                 }
         }
 }
 int main() {
         int row,col,m;
         cout<<"Rows: ";cin>>row;cout<<"Columns: ";cin>>col;
         m=row*col;
         gameCell p[row][col];
         gameConstruct(p[][col],m);
         gameDisplay(p[],row,col);
 }