18

我想制作一个类库，一个函数，它的参数是一个未知大小的矩阵，用户将用自己的大小创建自己的矩阵并将它传递给这个函数，对他的矩阵做一些这样的操作，将是功能

calculateDeterminantOfTheMatrix( int matrix[][])
{
   some Operations to do on matrix 
}
4

6 回答 6

23

C 和 C++ 的内置组件不太支持多维数组。只有在编译时N知道维度时，才能传递-dimension 数组：N-1

calculateDeterminantOfTheMatrix( int matrix[][123])

但是，标准库提供的std::vector容器非常适用于多维数组：在您的情况下，传递vector<vector<int> > &matrix将是在 C++ 中处理任务的正确方法。

int calculateDeterminantOfTheMatrix(vector<vector<int> > &matrix) {
    int res = 0;
    for (int i = 0 ; i != matrix.size() ; i++)
        for(int j = 0 ; j != matrix[i].size() ; j++)
            res += matrix[i][j];
    return res;
}

作为额外的好处，您不需要将矩阵的维度传递给函数：matrix.size()代表第一个维度，并matrix[0].size()代表第二个维度。

于 2012-04-15T17:24:25.790 回答
7

C解决方案：

在 C 中，作为函数参数传递时，您不能省略数组大小（最左边的除外）。

你可以写： int a[]

但不能： int a[][]

例如： int a[][20]

这个约束在这里，因为编译器需要确定访问数组元素的正确偏移量。但是，您可以这样做：

void print_arbitrary_2D_array(void *arr, int y, int x)
{
    /* cast to 2D array type */
    double (*p_arr)[y][x] = (double (*)[y][x]) arr;

    int i, j;

    for (i = 0; i < y; ++i) {
        for (j = 0; j < x; ++j)
            printf(" %lf", (*p_arr)[i][j]);
        putchar('\n');
    }
}

double arr_1[4][3] = {
    { 3.3, 5.8, 2.3 },
    { 9.1, 3.2, 6.1 },
    { 1.2, 7.9, 9.4 },
    { 0.2, 9.5, 2.4 }
};
double arr_2[2][5] = {
    { 3.6, 1.4, 6.7, 0.1, 4.2 },
    { 8.4, 2.3, 5.9, 1.4, 8.3 }
};

print_arbitrary_2D_array(arr_1, 4, 3);
putchar('\n');
print_arbitrary_2D_array(arr_2, 2, 5);
于 2016-02-26T16:48:34.373 回答
1

您可以采取多种方法。

  1. C 处事方式 -> 传入 aint**但此处要格外小心。这不是一个二维数组。您必须正确地为该指针分配内存，或者，您需要在编译时知道大小。（例如静态分配一个大小为 M * N 的数组，然后禁止任何更大的数组）。为了动态分配内存，您需要知道行数和列数。

  2. C ++方式->#include <vector>之后您可以简单地使用vector<vector<int> > &matrix（注意后面的空间，<int>除非您使用的是c ++ 11编译器。），它将分配一个基本上是二维数组的int向量向量。在这种情况下，将为您处理内存管理。

于 2012-04-15T17:29:33.887 回答
1

我会为定义了列和行的矩阵编写一个简单的类包装器。

template <typename T>
class Mat {
  std::size_t _row;
  std::size_t _col;

  T *_mat_elem;
public:
  Mat(std::size_t r, std::size_t c)
   :  _row(r), _col(c), _mat_elem(new T[r*c] {}
  ~Mat() {/* remember to do delete [] here */}

  // element access, for example
  T& at(std::size_t r, std::size_t c)
  {
    return *(_mat_elem+r*_col+c);
  }
};

但实际上你是在重新发明轮子。那里有很好的矩阵处理库。

于 2012-04-16T11:17:03.230 回答
0

使用此方法声明一个指针数组，例如： int *a[n]; 然后使用 for 循环为它们分配内存： 

for( int i=0 ; i<n ; i++ )
        a[i] = new int[n];

现在像普通数组一样传递参数。例如： print_array(a,n); 而 print_array 函数看起来像

print_array(int **a,int n)//the prototype for the print_array
{
 //access the array using index such as
std:: cout<<a[1][1]<<endl;
}

上述情况适用于 nxn 数组，如果需要 mxn 然后分配内存，如

for( int i=0 ; i<m ; i++ )
        a[i] = new int[n];

然后将 m,n 和传递给函数并在 for 循环中访问数组。

于 2019-03-23T16:22:01.673 回答
0

到目前为止，在我发现的函数中使用二维数组的最佳方法是使用映射函数。如下例所示，我使用映射函数来打印二维数组

void Print2D(int x[],int ROWS,int COLS)
{
    for(int i=0;i<ROWS;i++)
{
    for(int j=0;j<COLS;j++)
    cout << x[i*COLS+j] << ' ';
    cout << endl;

}
}

这是如何在 main 中使用它

int main(){

    int x[3][3];
    Print2D(&x[0],3,3);

}

这里 &x[0] 是二维数组第一行的起始地址或更准确地说是二维数组的起始地址

于 2019-05-26T10:06:09.230 回答