2

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

这是我的代码：

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

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

4

7 回答 7

2

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]) {
    ...
}
于 2012-06-11T23:02:57.147 回答
1

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

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

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

要索引到数组，使用类似的东西

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

您当然应该使用 define 或类似的东西来保持 11 的使用一致，但这不是这个答案的重点。

于 2012-06-11T23:03:07.257 回答
0

在以下代码片段中，

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）而不是使用123and 11。尝试定义 aMACRO并改用它。

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

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

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

此外，如果你能说出它到底是如何搞砸你的代码，它可能会更有帮助？例如，代码片段不仅可以说明其搞砸了，还可以提供更多帮助。它可以帮助其他人调查和解决问题。

于 2012-06-12T04:40:02.737 回答
0

如果您有一个现代 C 编译器（C99 可以），您甚至可以声明具有可变大小的真实二维矩阵。您无需使用指针回退到这种糟糕的仿真。

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

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

对于函数，您只需要确保在矩阵之前先声明nand 。m

于 2012-06-12T06:34:40.793 回答
0

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

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

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

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

于 2012-06-11T23:03:05.120 回答
0

有几种方法可以为 NxM 数组动态分配内存。这里有两个：

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

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

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

podrucje[i][j]您可以像任何其他二维数组一样 索引这个数组。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像任何其他数组一样使用索引它。在第二种情况下， eachpodrucje[i]是一个指向 double 的指针。由于a[i]被评估为*(a + i)，因此数组索引对指针表达式和数组表达式一样有效。

于 2012-06-13T11:16:38.693 回答
0 
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);
}
于 2012-06-13T11:19:49.510 回答