如何分配具有连续内存的二维数组？如何使用它来访问行和列？举个例子

Question

我创建了一个二维数组，其内容如下

     int i,j,lx,ly;// lx,ly are the row and column respectively
     double** a;

     a=(double**) malloc((lx+2)*sizeof(double));

     a[0]= (double*) malloc((lx+2)*(ly+2)* sizeof(double));

     assert(a[0]); 

     for(i=1;i<lx+2;i++)
     {
       a[i]=a[i-1]+i*(ly+2);
     }

// 我为该数组中的所有元素分配了 0 值，如下

    for(i=0;i<(lx+2)*(ly+2);i++)
    {
      a[i]=0;
    } 

// 我打印出下面的所有元素

      for(i=0;i<(lx+2)*(ly+2);i++)
      {
         printf("position %d values %d\n",i,a[i]);
      } 

// 当我看到输出时，它显示了一个垃圾某个特定位置 13 处的值。我无法弄清楚..还请告诉我如何访问行和列，例如以 lx、ly 的形式访问第 7 列第 0 行和第 5 行第 6 列，如下所示我的代码

Answer 1

你的方法肯定是朝着正确的大方向前进。

我认为：

a=(double**) malloc((lx+2)*sizeof(double));

通常是：

a = malloc(lx * sizeof(double *));

然后如果没有连续性要求，

a[0]= (double*) malloc((lx+2)*(ly+2)* sizeof(double));

在大多数程序中，这个： 看起来像：

a[0] = malloc(ly * sizeof(double));

最后，最后一行需要位于一个分配每个 a[i] 的循环中有它自己的 malloc'ed 空间。

但是，这不会创建连续的内存。为此，您需要进行大量分配，然后将其划分为行向量。因此，与其在循环中使用第二个 malloc，不如

double *t = malloc(lx * ly * sizeof(double));
for (i = 0; i < lx; ++i)
    a[i] = t + i * ly;

将其全部放在一起：

#include <stdio.h>
#include <stdlib.h>

void arrayDemo(int lx, int ly)
{
  double **a;
  int i, j;

  a = malloc(lx * sizeof(double *));
  double *t = malloc(lx * ly * sizeof(double));
  for(i = 0; i < lx; ++i)
    a[i] = t + i * ly;

  for(i = 0; i < lx; ++i)
    for(j = 0; j < ly; ++j)
      a[i][j] = i*100 + j;
  for(i = 0; i < lx; ++i) {
    for(j = 0; j < ly; ++j)
      printf(" %4.0f", a[i][j]);
    printf("\n");
  }
}

int main(int ac, char **av)
{
  arrayDemo(atoi(av[1]), atoi(av[2]));
  return 0;
}

$ cc -Wall all.c
$ ./a.out 4 7
    0    1    2    3    4    5    6
  100  101  102  103  104  105  106
  200  201  202  203  204  205  206
  300  301  302  303  304  305  306

Answer 2

此代码分配一个 10 x 5 的连续内存块，用递增双精度数对其进行初始化，然后打印由 x 和 y 索引的值：

#include "2d.h"

int main(void){

    unsigned int x,y;
    const unsigned int width = 10;
    const unsigned int height = 5;

    //we need an index into the x of the array
    double * index[width];

    //need the memory to store the doubles
    unsigned int memorySizeInDoubles = width * height;
    double * memory = malloc(memorySizeInDoubles * sizeof(double));

    //initialize the memory with incrementing values
    for(x = 0; x < memorySizeInDoubles; ++x){
        memory[x] = (double) x;
    }

    //initialize the index into the memory
    for(x = 0; x < width; ++x){
        index[x] = memory + height * x;
    }

    //print out how we did
    for(x = 0; x < width; ++x){
        for(y = 0; y < height; ++y){
           printf("[%u, %u]: Value = %f\n", x, y, index[x][y]);
        }
    }

    free(memory);

    return 0;
}

2d.h 文件应包含这些行：

#include <stdio.h>
#include <stdlib.h>

int main(void);

注意： 内存创建的内容仅对于某些定义是连续的。内存在逻辑上是连续的，但不一定是物理上连续的。例如，如果该内存用于设备驱动程序，则 malloc 将不起作用。

Answer 3

一维数组

double my_array = malloc(sizeof(double) * size_x * sizeof(double) * size_y);

您可以创建一个将通过其访问的

（获取位置 x=28，y=12）

my_array[12 * size_x + 28];

，也可以像您一样创建一个二维数组，但您可以使用

double **my_array = (double**) malloc(15 * sizeof(double));

for(int i = 0 ; i < 25; i++)
   {
   my_array[i] = (double*) malloc(30 * sizeof(double));
   for (int j = 0 ; j < 12; j++)
      {
      my_array[i][j] = 1.2;
      }
   }

double my_double = my_array[12][28];

Answer 4

在 C 中，要拥有一大块连续内存，您需要一个 malloc()，或者拥有一个静态分配的数组。由于您需要动态内存，因此需要malloc()。由于您需要所有内容都是连续的，因此您只需要一次调用它。

现在，调用应该是什么样子？如果我理解正确的话，您需要 lx 乘以 ly 值，每个值的大小为 sizeof(double)，因此您需要 lx* ly*sizeof(double) 要分配的字节。

题外话：我更喜欢按如下方式编写 malloc() 调用：

#include <stdlib.h> /* for malloc's prototype */
T *pt; /* for any type T */
size_t n; /* need n objects of type T */

pt = malloc(n * sizeof *pt);

使用 sizeof 和 sizeof *pt 而不是 sizeof(T)< /code> 的一个优点是，如果 pt 的类型发生变化，您无需更改 malloc() 调用。不强制转换 malloc() 的结果很好，因为这样整个 malloc() 调用就与类型无关，并且更容易键入和阅读。但请务必#include。

因此，要为 n double 分配空间，您可以这样做：

double *pd = malloc(n * sizeof *pd);
if (pd != NULL) {
    /* malloc succeeded */
} else {
    /* malloc failed */
}

现在，在分配内存之后，您需要能够对其进行索引。假设您有 lx == 2 和 ly == 3。您的内存看起来像：

    +---+---+---+---+---+---+
pd: | 0 | 1 | 2 | 3 | 4 | 5 |
    +---+---+---+---+---+---+

pd[0]、pd[1] 和 pd[2] 是 double与第一行对应的值，pd[3] 到 pd[6] 是与第二行对应的 double 值。您应该能够推广这一观察结果，将给定的 x,y 索引对转换为一个能够正确索引到您的 pd 数组的数字。