Question

我想声明正确的指针并为二维数组分配内存，并正确传递给函数。我无法正常工作并需要帮助。

这是我的代码：

    double **podrucje;
    podrucje=(double **) malloc (sizeof (double *) *123);
    for (i=0;i<(123);i++)
    {                       
        podrucje[i]=(double *) malloc (sizeof (double) * 11);
    }
    for (i=0;i<(123);i++)
    {   
        memset (podrucje[i], 0, 10);
    }

但是这段代码不起作用，它搞砸了我的整个程序。所以我决定放弃动态分配并使用它：

    double podrucje[123][11]={0};

但我不知道如何发送它并在功能中使用它......

Answer 1

memset基于每个字节工作。

double **podrucje = (double **) malloc (sizeof (double *) * 123);
for (i = 0; i < 123; i++)
{                       
    podrucje[i] = (double *) malloc (sizeof (double) * 11);
    memset(podrucje[i], 0, sizeof(double) * 11);
}

如果您想传递它，只需将其声明为

void function(double podrucje[123][11]) {
    ...
}

Answer 2

你最好使用malloc，但是在第二行分配整个数组，所以它都被分配在连续的内存中。所以

podrucje = (double*) malloc (sizeof (double) * 123 * 11);

然后第一个循环也可以消失。看起来你正在将数组初始化为0 - 在这种情况下，使用calloc代替malloc，消除第二个循环。

要索引数组，请使用

之类的内容

double myitem = podrucje [11 * row + col];

你当然应该使用一个定义或类似的来保持11的一致性，但这不是这个答案的重点。

Answer 3

以与编写变量定义相同的方式编写函数参数：

void myfunc(double podrucje[123][11])
{
    ...
}

double podrucje[123][11];
myfunc(podrucje);

请注意，数组是“通过引用”传递而不是复制。

Answer 4

在以下代码段中，

podrucje[i]=(double *) malloc (sizeof (double) * 11);
for (i=0;i<(123);i++)
{   
    memset (podrucje[i], 0, 10);
}

1）您不需要针对数字123和11的额外括号 for循环可以如下，

for (i = 0; i < 123; i++)

2）而不是使用123和11。尝试定义MACRO并改为使用它。

优点：代码独立于特殊数字，易于维护。特别是在代码库较大的情况下。

3）如果您阅读了代码，podrucje[i] is allocated a memory of 11 doubles但是当您memset时，您只设置了10次，而最后一次可能包含或不包含垃圾。在这里使用calloc，它不仅分配了内存，还初始化了内存。

podrucje[i]=(double *) calloc(11,sizeof(double));

如果你能告诉它如何搞砸你的代码，那么它会更有帮助吗？例如，代码片段可能不仅仅是说明其搞砸了。它可以帮助其他人调查和解决问题。

Answer 5

如果你有一个现代的C编译器（C99会做），你甚至可以声明具有可变大小的真实2D矩阵。你不需要使用指针回退到这个糟糕的模拟。

void myfunc(size_t n, size_t m, double podrucje[n][m])
{
    ...
}

double (*podrucje)[n] = malloc(sizeof(double[n][m]));
myfunc(n, m, podrucje);

对于该功能，您只需确保n和m的声明在矩阵之前排在第一位。

Answer 6

有几种方法可以为NxM阵列动态分配内存。这是两个：

您可以声明指向M元素数组的指针，然后声明malloc N个实例：

double (*podrucje)[11] = malloc(sizeof *podrucje * 123);

从C89开始，您不需要投射malloc的结果，并且不鼓励这种做法。另请注意，sizeof的操作数是表达式*podrucje;这给了我与sizeof (double) * 11相同的结果。

您可以将此数组索引为podrucje[i][j]，就像任何其他2D数组一样。 podrucje[i]隐式取消引用指针（请记住a[i]等同于*(a + i)），因此您无需对其执行任何操作。

您可以在函数中使用它，如下所示：

void init(double (*podrucje)[11], size_t rows)
{
  size_t i, j;
  for (i = 0; i < rows; i++)
    for (j = 0; j < 11; j++)
      podrucje[i][j] = 0.0;
}

将被称为

init(podrucje, 123);

这种方法的缺点是该功能只能在Nx11阵列上运行;如果您使用的是C99编译器或支持可变长度数组的C2011编译器，则可以将列数指定为运行时变量：

void foo(void)
{
  size_t rows = 123, cols = 11;
  double (*podrucje)[cols] = malloc(sizeof *podrucje * rows);
  if (podrucje)
    init(cols, podrucje, rows);
  ...
}

// cols must be declared before it can be used
// in an array declarator
//
void init(size_t cols, double(*podrucje)[cols], size_t rows)
{
  size_t i, j;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      podrucje[i][j] = 0.0;
}

完成数组后，按如下方式解除分配：

free(podrucje);

另一种方法是分别分配每一行，如下所示：

size_t rows = 123, cols = 11;
double **podrucje = malloc(sizeof *podrucje * rows);
if (!podrucje)
{
  // malloc failed; handle allocation error here
}
else 
{
  size_t i;
  for (i = 0; i < rows; i++)
  {
    podrucje[i] = malloc(sizeof *podrucje[i] * cols);
    if (!podrucje[i])
    {
      // malloc failed; handle allocation error here
    }
  }
}

你可以在函数中使用它，如下所示：

void foo()
{
  double **podrucje;
  // allocate array as above
  init(foo, rows, cols);
  ...
}

void init(double **podrucje, size_t rows, size_t cols)
{
  size_t i, j;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      podrucje[i][j] = 0.0;
}

完成数组后，按如下方式解除分配：

for(i = 0; i < rows; i++)
  free(podrucje[i]);
free(podrucje);

第一种方法将内存分配为单个连续块;第二个将它分配给一系列较小的不连续块。如果您的阵列特别大或您的堆特别碎片化，第一种方法可能会失败，第二种方法将成功。如果您正在使用不支持可变长度数组的编译器，则第一种方法的灵活性要低得多，因为必须在编译时指定列数。

同样的索引方法如何适用于这两种形式？

在第一种情况下，每个podrucje[i]是一个11个元素的double数组;使用j索引它与任何其他数组一样。在第二种情况下，每个podrucje[i]都是指向double的指针。由于a[i]被评估为*(a + i)，因此数组索引对指针表达式以及数组表达式起作用。

Answer 7

int print_func(char((*p)[26])[10])
{
    int i = 0;
    for (i=0; i < 26 ; i++) {
        fprintf(stderr, "%02d:%.*s\n", i, 10, p[0][i]);
    }
    return (0);
}

int main(void)
{
    int nrow = 26;
    int ncol = 10;
    char((*p)[26])[10] = (char((*)[26])[10])(0);
    char(*q)[10];
    char c = 'a';
    int i = 0;

    p = (char((*)[26])[10])malloc(sizeof(char) * nrow * ncol);
    if ((char((*)[26])[10])0 == p) {
            return (-1);
    }
    for (i=0, q=p[0]; i < nrow ; i++) {
        memset(q, c, sizeof(char) * ncol);
        c++;
        q++;
    }
    for (i=0,q=p[0] ; i < nrow ; i++) {
        fprintf(stderr, "%.*s\n", 10, q);
        q++;
    }

    p[0][8][0]='z';
    getchar();
    print_func(p);
    return (0);
}

如何声明指针并为二维数组分配内存并传递给函数

7 个答案: