C语言 如何分配和释放堆内存的二维数组

Question

我已经习惯了PHP，但是我正在开始学习c。我正在尝试创建一个程序，逐行读取文件并将每行存储到数组中。

到目前为止，我有一个程序逐行读取文件，甚至打印每一行，但现在我只需要将每一行添加到数组中。 我的朋友昨晚跟我说了一点。他说我必须在C中使用一个多维数组，所以基本上是array[x][y]。[y]部分本身很简单，因为我知道每行的最大字节数。但是，我不知道该文件有多少行。

我想我可以让它循环遍历文件，每次只增加一个整数，然后使用它，但我觉得可能有一种更简单的方法。

接下来我可以尝试什么?

Answer 1

动态分配二维数组:

char **p;
int i, dim1, dim2;

/* Allocate the first dimension, which is actually a pointer to pointer to char   */
p = malloc (sizeof (char *) * dim1);
/* Then allocate each of the pointers allocated in previous step arrays of pointer to chars
 * within each of these arrays are chars
 */
for (i = 0; i < dim1; i++)
  {
    *(p + i) = malloc (sizeof (char) * dim2);
   /* or p[i] =  malloc (sizeof (char) * dim2); */
  }
 /* Do work */
/* Deallocate the allocated array. Start deallocation from the lowest level.
 * that is in the reverse order of which we did the allocation
 */
for (i = 0; i < dim1; i++)
{
  free (p[i]);
}
free (p);

修改上述方法。当你需要另一行添加*(p + i) = malloc (sizeof (char) * dim2);和更新i。在这种情况下，您需要预测由dim1变量指示的文件中的最大行数，我们第一次为此分配p数组。这将只分配(sizeof (int *) * dim1)字节，因此比char p[dim1][dim2](在c99中)要好得多。

我有另一种想法。以块的形式分配数组，并在溢出时将它们链接起来。

struct _lines {
   char **line;
   int n;
   struct _lines *next;
} *file;
file = malloc (sizeof (struct _lines));
file->line = malloc (sizeof (char *) * LINE_MAX);
file->n = 0;
head = file;

之后，第一个块就可以使用了。当你需要插入一行时，只需执行:

/* get line into buffer */
file.line[n] = malloc (sizeof (char) * (strlen (buffer) + 1));
n++;

当n为LINE_MAX时，分配另一个块并将其链接到此块。

struct _lines *temp;
temp = malloc (sizeof (struct _lines));
temp->line = malloc (sizeof (char *) * LINE_MAX);
temp->n = 0;
file->next = temp;
file = file->next;

就像这样。

当一个块的n变成0时，释放它，并将当前块指针file更新为前一个。您可以从开始的单个链表遍历和从开始遍历或使用双链接。

Answer 2

在c语言中没有标准的可调整大小的数组类型，你必须自己实现它，或者使用第三方库。下面是一个简单的示例:

typedef struct int_array
{
    int *array;
    size_t length;
    size_t capacity;
} int_array;
void int_array_init(int_array *array)
{
    array->array = NULL;
    array->length = 0;
    array->capacity = 0;
}
void int_array_free(int_array *array)
{
    free(array->array);
    array->array = NULL;
    array->length = 0;
    array->capacity = 0;
}
void int_array_push_back(int_array *array, int value)
{
    if(array->length == array->capacity)
    {
        // Not enough space, reallocate.  Also, watch out for overflow.
        int new_capacity = array->capacity * 2;
        if(new_capacity > array->capacity && new_capacity < SIZE_T_MAX / sizeof(int))
        {
            int *new_array = realloc(array->array, new_capacity * sizeof(int));
            if(new_array != NULL)
            {
               array->array = new_array;
               array->capacity = new_capacity;
            }
            else
                ; // Handle out-of-memory
        }
        else
            ; // Handle overflow error
    }
    // Now that we have space, add the value to the array
    array->array[array->length] = value;
    array->length++;
}

像这样使用:

int_array a;
int_array_init(&a);
int i;
for(i = 0; i < 10; i++)
    int_array_push_back(&a, i);
for(i = 0; i < a.length; i++)
    printf("a[%d] = %dn", i, a.array[i]);
int_array_free(&a);

当然，这只适用于int s数组。由于C语言没有模板，您必须为每种不同类型的数组将所有这些代码放在宏中(或者使用不同的预处理器，例如GNU m4)。或者，您可以使用通用数组容器，该容器使用void*指针(要求所有数组元素都是malloc 'ed)或不透明内存blob，这将要求对每个元素访问进行强制转换，并对每个元素get/set进行memcpy。

无论如何，它都不漂亮。二维数组就更难看了

Answer 3

这里也可以使用链表而不是数组。代码更简单，但分配更频繁，可能会出现碎片。

只要你不打算做太多的随机访问(这里是O(n))，迭代就和普通数组一样简单。

typedef struct Line Line;
struct Line{
    char text[LINE_MAX];
    Line *next;
};
Line *mkline()
{
    Line *l = malloc(sizeof(Line));
    if(!l)
       error();
    return l;
}
main()
{
    Line *lines = mkline();
    Line *lp = lines;
    while(fgets(lp->text, sizeof lp->text, stdin)!=NULL){
         lp->next = mkline();
         lp = lp->next;
    }
    lp->next = NULL;
}

Answer 4

如果使用C语言，则需要自己实现数组的大小调整。c++和SDL已经为您完成了这些工作。它被称为vector。http://www.cplusplus.com/reference/stl/vector/

Answer 5

虽然多维数组可以解决这个问题，但矩形二维数组并不是真正自然的C解决方案。

下面的程序首先将文件读入链表，然后分配一个大小合适的指针向量。然后每个单独的字符都显示为array[line][col]，但实际上每行只有它需要的长度。除<err.h>外均为C99。

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct strnode {
  char *s;
  struct strnode *next;
} strnode;
strnode *list_head;
strnode *list_last;
strnode *read1line(void) {
  char space[1024];
  if(fgets(space, sizeof space, stdin) == NULL)
    return NULL;
  strnode *node = malloc(sizeof(strnode));
  if(node && (node->s = malloc(strlen(space) + 1))) {
    strcpy(node->s, space);
    node->next = NULL;
    if (list_head == NULL)
      list_head = node;
    else
      list_last->next = node;
    list_last = node;
    return node;
  }
  err(1, NULL);
}
int main(int ac, char **av) {
  int n;
  strnode *s;
  for(n = 0; (s = read1line()) != NULL; ++n)
    continue;
  if(n > 0) {
    int i;
    strnode *b;
    char **a = malloc(n * sizeof(char *));
    printf("There were %d linesn", n);
    for(b = list_head, i = 0; b; b = b->next, ++i)
      a[i] = b->s;
    printf("Near the middle is: %s", a[n / 2]);
  }
  return 0;
}

Answer 6

您可以使用malloc和realloc函数来动态分配和调整指向char的指针数组的大小，数组的每个元素将指向从文件中读取的字符串(该字符串的存储空间也是动态分配的)。为简单起见，我们假设每行的最大长度小于M个字符(包括换行符)，因此我们不必动态调整每行的大小。

您需要在每次扩展数组时手动跟踪它的大小。一种常见的技术是每次扩展时将数组大小增加一倍，而不是扩展一个固定的大小;这将最小化对realloc的调用数量，这可能是昂贵的。当然，这意味着你必须跟踪两个量;数组的总大小和当前已读的元素数。

的例子:

#define INITIAL_SIZE ... // some size large enough to cover most cases
char **loadFile(FILE *stream, size_t *linesRead)
{
  size_t arraySize = 0;   
  char **lines = NULL;
  char *nextLine = NULL;
  *linesRead = 0;
  lines = malloc(INITIAL_SIZE * sizeof *lines);
  if (!lines)
  {
    fprintf(stderr, "Could not allocate arrayn");
    return NULL;
  }
  arraySize = INITIAL_SIZE;
  /**
   * Read the next input line from the stream.  We're abstracting this
   * out to keep the code simple.
   */
  while ((nextLine = getNextLine(stream)))  
  {
    if (arraySize <= *linesRead)
    {
      char **tmp = realloc(lines, arraysSize * 2 * sizeof *tmp);
      if (tmp)
      {
        lines = tmp;
        arraySize *= 2;
      }
    }
    lines[(*linesRead)++] = nextLine;
  )
  return lines;
}