1

我的行大小是固定的，但列大小一直在变化。这就是为什么我想在列级别使用指针。但我不确定如何在 C 中使用此功能。请帮助我。

int array[rows][columns]; //row size fixed but column size is not fixed.
4

6 回答 6

0

您需要声明一个指针数组。像这样：

int *array[rows];

后来根据需要，给每一行分配内存。您可以为此使用 malloc 或 calloc 函数。

for(int i=0; i<rows; i++){
    array[i] = (int *) malloc(columns * sizeof(int));
}

此方法还允许具有不同大小的行。

于 2012-04-30T13:48:55.887 回答
0

如果除了一个维度之外的所有数组都是固定的，这就是您描述的情况，您可以避免使用指针数组：您可以将一行定义为int[rows]，并创建一个行数组，如下所示：

typedef int row_t[rows];

现在您可以传递由如下数组组成的二维数组row_t：

int total(row_t array[], int len) {
    int res = 0;
    for (int c = 0 ; c != len ; c++) {
        for (int r = 0 ; r != rows ; r++) {
            res += array[r][c];
        }
    }
    return res;
}

int main() {
    row_t *matrix = malloc(columns*sizeof(row_t));
    for (int c = 0 ; c != columns ; c++) {
        for (int r = 0 ; r != rows ; r++) {
            matrix[r][c] = r*r+c*c;
        }
    }
    printf("%d\n", total(matrix, columns));
    free(matrix);
    return 0;
}
于 2012-04-30T13:49:11.843 回答
0

您不能在数组维度中使用变量，因此请使用指向指针的指针

int **array;

array = (int **)malloc(sizeof(int *) * rows);
for (int i = 0; i < rows; ++i) {
    array[i] = (int *)malloc(sizeof(int) * columns); 
    for (int j = 0; j < columns; j++) {
       array[i][j] = value;
    }
}

当然不要忘记释放它

于 2012-04-30T13:49:20.300 回答
0

您可以通过拥有一个 int* 数组来做到这一点，例如

int* array[row];
for (int i = 0; i < row; ++i)
    array[i] = (int*)malloc(i * sizeof(int));

然后您可以像访问静态数据一样访问数据。

int val = array[myRow][myColumn];

您必须确保以与分配内存相同的模式释放内存。

于 2012-04-30T13:51:14.467 回答
0

自 13 年以来，现在 C 允许在声明数组时使用动态大小。这称为可变长度数组，VLA。

如果你真的有大数组，这可能会爆炸你的堆栈。但是您仍然可以malloc使用 2D 数组的所有简单性来分配这样的野兽：

size_t n = SOME_COMPLICATED_VALUE;
size_t m = ANOTHER_ONE;
double (*A)[n] = malloc(double[m][n]);
于 2012-04-30T13:57:43.950 回答
0

如果每一行可以有不同的列数，那么一般的做法是声明一个指针数组，然后为每一行动态分配该行的元素数：

int *array[ROWS];

array[i] = malloc(sizeof *array[i] * number_of_columns_for_row_i);

请注意，完成后，您必须单独释放每一行：

for (i = 0; i < ROWS; i++)
  free(array[i]);

如果所有行的列数都相同，但对于数组的每个实例，该数字可能会发生变化，那么您有多种选择。如果您使用的是符合 C99 的编译器，则可以使用可变长度数组，其中数组维度直到运行时才知道：

int columns;

// get number of columns somehow

int array[ROWS][columns];

VLA 很方便，但也有其局限性；它们不能是成员struct或union类型，也不能被声明static或在文件范围内。这种方法的最大优点是您不必担心在完成后释放任何东西。这种方法的最大缺点是您可能没有足够的内存来满足请求；与动态分配对象的内存相比，可用于变量的内存空间auto通常非常有限。此外，语言标准 (C11) 的最新版本使 VLA 成为可选，因此它们可能不会在未来的所有实现中都可用。

或者，您可以像这样动态分配数组：

int (*array)[ROWS];
int columns;

// get number of columns somehow

array = malloc(sizeof *array * columns);

请注意，这一次，array是指向 的数组int的指针，而不是指向 的指针数组int。这种方式的好处是数组内存是连续分配的，free-ing内存就像写一样简单

free(array);

缺点是如果你的数组真的很大或者动态内存池真的很碎片化，你可能没有足够大的内存块来满足请求。

如果您不需要连续分配所有行，则使用第一种单独分配每一行的方法；只需对列数使用相同的值：

int *array[ROWS];
int columns;

// get number of columns

for (i = 0; i < ROWS; i++)
  array[i] = malloc(sizeof *array[i] * columns);
于 2012-04-30T14:20:05.357 回答