C++ 将大小未知的数组传递给函数

假设我有一个名为

MyFunction（int-myArray[][]）

的函数，它执行一些数组操作

如果我这样写参数列表，编译器会抱怨它需要在编译时知道数组的大小。是否有方法重写参数列表，以便我可以将任意大小的数组传递给函数

我的数组的大小由类中的两个

静态常量int

s定义，但编译器不会接受类似

MyFunction（int-myArray[Board:：ROWS][Board:：COLS]）

的内容

如果我可以将数组转换为向量，然后将向量传递给

MyFunction

，会怎么样？我是否可以使用单行转换，或者我必须手动进行转换？

是：

MyFunction（int**myArray）

不过要小心。你最好知道你在做什么。这将只接受int指针数组

由于您试图传递数组数组，因此需要一个常量表达式作为维度之一：

MyFunction（int-myArray[][COLS]）

您需要在编译时使用
COLS

我建议使用A。< /P> < P>传递指针并自己做索引，或者使用矩阵类代替。C++中的
< P>使用STD:：vector，除非使用特定的数组，否则，使用数组。
正在初始化一个3x2向量，其中填充了称为“myArray”的0：

vector< vector<int> > myArray(3, vector<int>(2,0));

如果您需要传入一个可变长度数组（动态分配的，或者可能只是一个需要采用不同大小数组的函数），那么您需要处理

正如对该答案的评论所述：

multiarray可能更合适，因为它可以更有效地建模多维数组。向量向量在关键路径代码中可能会影响性能，但在典型情况下，您可能不会注意到问题

使用
向量
（如果不能保证底层存储是连续的，这将是欺骗）

使用指向数组的
元素（
int*
）的指针和
size
（
M*N
）参数。这里有龙

将其作为指针传递，并将维度作为参数

void foo(int *array, int width, int height) {
    // initialize xPos and yPos
    assert(xPos >= 0 && xPos < width);
    assert(yPos >= 0 && yPos < height);
    int value = array[yPos * width + xPos];
}

void foo（int*数组、int宽度、int高度）{
//初始化XPO和YPO
断言（xPos>=0&&xPos=0&&yPos

这是假设您有一个简单的二维数组，如
intx[50][50]
使用
MyFunction（int*myArray[]）


如果使用
MyFunction（int**myArray）
pass
intsomearray[X][Y]
，程序将崩溃。

编辑：不要使用第一行，注释中会解释它。
是-只需将其作为指针传递即可：

缺点是您可能还需要对数组的长度进行pas
您不能传递这样的任意大小；编译器不知道如何生成指针算法。你可以这样做：

MyFunction(int myArray[][N])

或者你可以：

MyFunction(int *p, int M, int N)

但是在调用第一个元素时，必须获取它的地址（即
MyFunction（&arr[0][0]，M，N）

您可以通过使用容器类来解决C++中的所有这些问题；<代码> STD:：vector 是一个好的开始位置。
 < p>编译器抱怨，因为它需要知道所有的大小，但第一个维度能够处理数组中的元素。例如，在下面的代码中：

int array[M][N];
// ...
array[i][j] = 0;

为了处理元素，编译器生成如下内容：

*(array+(i*N+j)) = 0;

因此，您需要像这样重新书写您的签名：

MyFunction(int array[][N])

在这种情况下，您将不得不使用固定的尺寸标注，或者使用更通用的解决方案，例如（自定义）在C++语言中，多维数组声明必须总是包括所有的大小，可能是第一个。因此，你不能做的是声明一个内置多维数组类型的参数，而不显式地指定大小。
如果需要将运行时大小的多维数组传递给函数，可以忽略使用内置多维数组类型。这里一个可能的解决方法是使用“模拟”多维数组（指向其他1D数组的指针的1D数组；或通过索引重新计算模拟多维数组的普通1D数组）.
首先，让我们看看编译器为什么抱怨

如果数组定义为
int-arr[ROWS][COLS]；
则任何数组表示法
arr[i][j]
都可以转换为指针表示法，如下所示：

*( arr + i * COLS + j )

请注意，表达式只需要
COLS
，而不需要
行
。因此，数组定义可以等效为

int arr [][ COLS ];

但是，缺少第二维度是不可接受的

现在，关于你的问题：

有没有办法重写
参数列表，以便我可以传递
函数的任何大小的数组

是的，也许您可以使用指针，例如
MyFunction（int*arr）；
。但是，想想看，
MyFunction（）
如何知道停止访问数组的位置？要解决这个问题，您需要数组长度的另一个参数，例如
MyFunction（int*arr，size\t arrSize） 
 < P>我不知道C++，但是C99标准引入了可变长度数组。

因此，这将在支持C99的编译器中工作：

void func(int rows, int cols, double[rows][cols] matrix) {
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            printf("%f", matrix[r][c]);
        }
    }
}

对于三个或更多的维度，除了第一个维度外，所有维度都必须具有已知的大小。阿伦沙链接的答案解释了原因

诚实地说，我不知道C++是否支持可变长度数组，所以这可能是或可能不起作用。在任何一种情况下，你也可以考虑将数组封装在某种矩阵类中。
编辑：MyFunction(int *p, int M, int N)

int array[M][N];
// ...
array[i][j] = 0;

*(array+(i*N+j)) = 0;

MyFunction(int array[][N])

*( arr + i * COLS + j )

int arr [][ COLS ];

void func(int rows, int cols, double[rows][cols] matrix) {
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            printf("%f", matrix[r][c]);
        }
    }
}

void func(int rows, int cols, double[][cols] matrix)

template <std::size_t rows, std::size_t cols>
void function( int (&array)[rows][cols] )
{
   // ...
}

struct test {
   static const int rows = 25;
   static const int cols = 80;
};
void function( int *array[80], int rows ) {
   // ...
}

MyFunction(Board theBoard)
{
    ...
}

MyFunction(std::initializer_list<std::initializer_list<int>> myArray);

for (const std::initializer_list<int> &subArray: myArray)
{
    for (int value: subArray)
    {
        // fun with value!
    }
}

struct Board
{
    static const int ROWS = 6;
    static const int COLS = 7;
};

void MyFunction(int myArray[Board::ROWS][Board::COLS])
{
}