3

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

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

如何在函数后面访问这个数组的元素？

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

- - -编辑 - -

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

------edit----- 如何定义从调用函数传递一个二维数组？

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 **'

4

5 回答 5

1

如果大小未知，您可以使用float *tree指向一维数组的简单指针。然而，转向特定元素的语法不会像二维数组那样：

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

更新

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

#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;
}
于 2012-08-16T07:05:47.673 回答
1

使用指针..

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

功能定义：

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


}

我想这会对你有所帮助。

于 2012-08-16T06:55:37.543 回答
0 
#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
        }
    }
}
于 2012-08-16T07:21:31.133 回答
0

第一个想法是使用向量。但是，如果您使用的是 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);
于 2012-08-16T06:54:47.477 回答
0

在现代 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);
于 2012-08-16T07:40:50.707 回答