Question

这是传递未知大小的二维数组的正确方法是什么？

reprVectorsTree::reprVectorsTree(float tree[][], int noOfVectors, int dimensions)

稍后如何在函数中访问此数组的元素？

如何从调用函数传递二维数组？

----- ----编辑

我想用数组做，因为调用是从c代码完成的，并且有一个c到c ++接口

- - - - - - - - 编辑如何定义从调用函数传递二维数组？

float tree[15][2] = {{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1}};

reprVectorsTree *r1 = new reprVectorsTree(tree[0][0],8,2);

上面的代码有什么问题？我得到一个无法将参数1从'float'转换为'float **'

Answer 1

使用指针..

     reprVectorsTree(tree, noOfVectors, dimensions);// Calling function.

功能定义：

reprVectorsTree(float **tree, int noOfVectors, int dimensions){


}

我认为这会对你有所帮助。

Answer 2

如果大小未知，则可以使用指向1D数组的简单float *tree指针。转向特定元素的语法不会像2D数组那样：

reprVectorsTree::reprVectorsTree(float *tree, int noOfVectors, int dimensions)
{
    ...
    tree[ row_number * dimensions + column_number ] = 100.234;
}

在调用代码中，您将拥有以下内容：

float d2array[ROWS][COLUMNS];
...
reprVectorsTree(&d2array[0][0], ROWS, COLUMNS);

<强>更新

考虑以下传递2D数组的不同方法示例：

#include <iostream>
#include <malloc.h>

float test[2][4] = 
{
   {3.0, 4.0, 5.0, 0},
   {6.0, 7.0, 8.0, 0}
};

void print(float *root, int rows, int columns)
{
   for (int row = 0; row < rows; ++row)
   {
      for (int col = 0; col < columns; ++col)
      {
         std::cout << root[row * columns + col ] << " ";
      }
      std::cout << std::endl;
   }
}

float *test2[2] = 
{
   &test[0][0],
   &test[1][0],
};

void print2(float **root, int rows, int columns)
{
   for (int row = 0; row < rows; ++row)
   {
      for (int col = 0; col < columns; ++col)
      {
         std::cout << root[row][col] << " ";
      }
      std::cout << std::endl;
   }
}

int main()
{
   print(&test[0][0], 2, 4);
   //print(test2, 2, 4); // doesn't work

   print2(test2, 2, 4);
   //print2(&test[0][0], 2, 4); // doesn't work
   //print2(&test[0], 2, 4); // doesn't work

   float **dynamic_array = (float **)malloc(2 * sizeof(float *));
   dynamic_array[0] = (float *)malloc(4 * sizeof(float));
   dynamic_array[1] = (float *)malloc(4 * sizeof(float));

   for (int row = 0; row < 2; ++row)
   {
      for (int col = 0; col < 4; ++col)
      {
         dynamic_array[row][col] = (float)(row * 4 + col);
      }
   }

   print2(dynamic_array, 2, 4);
   //print(dynamic_array, 2, 4); // doesn't work

   return 0;
}

Answer 3

第一个想法是使用矢量。但是，如果您正在使用C代码，请将其作为reprVectorsTree(float** tree, int noOfVectors, int dimensions)传递。

对于你的情况：

float tree[15][2] = {{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1},{2,1}};

int nRows = 15;
int nCols = 2;

float** arr = new float*[nRows];

for (int i = 0; i < nRows; ++i) {
     arr[i] = new float[nCols];
}

for (int i = 0; i < nRows; ++i) {
    for (int j = 0; j < nCols; ++j) {
        arr[i][j] = tree[i][j];
    }
}

reprVectorsTree *r1 = new reprVectorsTree(arr, nRows, nCols);

Answer 4

#include <iostream>
using namespace std;

int
main(void)
{
    int layers = 3; // can be calculated in run-time
    int elem = 5; // can be calculated in run-time
    int* pArray = new int[layers * elem];
    /* usage */
    for (int i = 0; i < sizeof(pArray) / sizeof(pArray[0]); ++i) // traverse through layers
    {

        for (int j = 0; j < sizeof(pArray[0])/ sizeof(int); ++j) // traverse through elements in layer
        {
            // do some stuff
        }
    }
}

Answer 5

在现代C中，从C99开始，它很简单

void foo(size_t n, size_t m, double A[n][m]) {
  //
}

然后你走了。您唯一需要考虑的是尺寸必须位于参数列表中的数组之前。

为避免在呼叫方的堆栈上分配这样的野兽，你应该这样做

double (*A)[m] = malloc(sizeof(double[n][m]));

这样的“矩阵”可以像您习惯使用A[i][j]一样使用foo只是看起来像

foo(n, m, A);

如果在编译时两个维度都是未知的，如何传递二维数组

5 个答案: