Question

在我的代码中，我输入两个维度的大小，然后声明一个二维数组。我的问题是，如何将该数组用作函数参数？我知道我需要在函数规范中写出列数，但是如何传递列数？

 void gameDisplay(gameCell p[][int &col],int a,int b) {
         for(int i=0;i<a;i++) {
                for(int j=0;j<b;j++) {
                         if(p[i][j].getStat()==closed)cout<<"C ";
                         if(p[i][j].getStat()==secure)cout<<"S ";
                         if(p[i][j].getBomb()==true&&p[i][j].getStat()==open)cout<<"% ";
                         if(p[i][j].getBomb()==false&&p[i][j].getStat()==open) {
                                 if(p[i][j].getNum()==0)cout<<"0 ";
                                 else cout<<p[i][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[][col],row,col);
 }

我试过这种方式，但它不起作用。

谢谢。

Answer 1

在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]);

该函数将被实例化为传递给它的所有不同大小的数组。必须在编译时知道模板参数（数组的维度）。

Answer 2

我做了一个小程序：

#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;
}

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

Answer 3

这就是你要找的东西吗？

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]: %i\n", 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;
}

Answer 4

我猜测Problems with '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;   
}

Answer 5

如果您使用的是C风格的数组，则可能需要在参数中进行引用：

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

Answer 6

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

此外，您可以将函数的原型更改为“void gameDisplay（gameCell p []，int a，int b）”

固定代码：

a*b

输入二维数组的大小

6 个答案: