3

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

     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 向我显示一个垃圾值。我无法弄清楚.. 还请告诉我如何访问行和列，例如访问第 7 列第 0 行和第 5 行以 lx 为单位的第 6 行第 6 列，如我的代码所示

4

4 回答 4

5

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

我认为这：

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
于 2010-02-14T01:27:29.690 回答
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 将不起作用。

于 2010-02-14T02:28:55.720 回答
0

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

现在，调用应该是什么样子？如果我理解正确，您需要lx时间ly值，每个值都有 size 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);

使用sizeofwithsizeof *pt而不是sizeof(T)提供了一个优势，即如果类型发生pt变化，您无需更改malloc()调用。不强制转换结果malloc()很好，因为整个malloc()调用与类型无关，并且更易于输入和阅读。一定要#include <stdlib.h>。

因此，要为n doubles 分配空间，您可以执行以下操作：

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]topd[6]是double第二行对应的值。您应该能够概括此观察结果，以将给定的x,y索引对转换为正确索引到您的pd数组中的一个数字。

于 2010-02-15T05:33:11.417 回答
0

您要么创建一个单维数组

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];
于 2010-02-14T01:17:05.253 回答