如何在 C 中动态分配内存和确定数组大小？

Question

我正在尝试从 python 背景自学 C。我目前的小问题是尝试减少对数组长度等事情的硬编码，并根据输入动态分配内存。

我编写了以下程序。我希望社区提供建议以通过以下方式对其进行修改：

1.) 使 first 和 last Name 元素可变长度。目前它们的长度被硬编码为MAX_NAME_LENGTH。这将涉及更改 Names structdeclaration 以及我为其元素分配值的方式。

2.) 奖励：想办法逐步向name_list 数组添加新元素，而无需事先确定其长度。基本上使它成为一个可扩展的列表。

/* namelist.c 

   Loads up a list of names from a file to then do something with them.

*/
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>

#define DATAFILE "name_list.txt"
#define DATAFILE_FORMAT "%[^,]%*c%[^\n]%*c"
#define MAX_NAME_LENGTH 100

typedef struct {
  char first[MAX_NAME_LENGTH];
  char last[MAX_NAME_LENGTH];
} Name;


int main() {
  FILE *fp = fopen(DATAFILE, "r");

  // Get the number of names in DATAFILE at runtime.
  Name aName;
  int lc = 0;
  while ((fscanf(fp, DATAFILE_FORMAT, aName.last, aName.first))!=EOF) lc++;
  Name *name_list[lc];

  // Now actually pull the data out of the file
  rewind(fp);
  int n = 0;
  while ((fscanf(fp, DATAFILE_FORMAT, aName.last, aName.first))!=EOF)
  {
    Name *newName = malloc(sizeof(Name));
    if (newName == NULL) {
      puts("Warning: Was not able to allocate memory for ``Name`` ``newName``on the heap.");
    } 
    memcpy(newName, &aName, sizeof(Name));
  name_list[n] = newName;
  n++;
  }

  int i = 1;
  for (--n; n >= 0; n--, i++) {
    printf("%d: %s %s\n", i, name_list[n]->first, name_list[n]->last);
    free(name_list[n]);
    name_list[n] = NULL;
  }

  fclose(fp);
  return 0;
}

name_list.txt的示例内容：

Washington,George
Adams,John 
Jefferson,Thomas
Madison,James

更新 1：

我已经按照@Williham 的建议实现了一个链表和一些辅助函数，结果如下。

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

#define DATAFILE "name_list.txt"
#define MAX_NAME_LENGTH 30
#define DATAFILE_FORMAT "%29[^,]%*c%29[^\n]%*c"

static const int INPUT_BUFFER_SIZE_DEFAULT = sizeof(char) * MAX_NAME_LENGTH;

typedef struct _Name Name;

struct _Name {
  char *first;
  char *last;
  Name *next;
};

int get_charcount(char *str);

Name * create_name_list(char *filename);
void print_name_list(Name *name);
void free_name_list (Name *name);

int main() {

  // Read a list of names into memory and 
  // return the head of the linked list.
  Name *head = create_name_list(DATAFILE);

  // Now do something with all this data.
  print_name_list(head);

  // If you love something, let it go.
  free_name_list(head);
  head = NULL;
  return 0;
}

int get_charcount (char *str) 
{
  int input_length = 1;
    while (str[input_length] != '\0')
    {
      input_length++;
    }
  return input_length;
}

Name * create_name_list(char *filename)
{
  FILE *fp = fopen(DATAFILE, "r");
  char *first_input_buffer = malloc(INPUT_BUFFER_SIZE_DEFAULT);
  char *last_input_buffer = malloc(INPUT_BUFFER_SIZE_DEFAULT);

  Name *firstNamePtr;
  Name *previousNamePtr;
  while ((fscanf(fp, DATAFILE_FORMAT, last_input_buffer, first_input_buffer))!=EOF)
  {
    Name *newNamePtr = malloc(sizeof(Name));

    if (previousNamePtr) 
    {
      previousNamePtr->next = newNamePtr;
      previousNamePtr = newNamePtr;
    } 
    else 
    {
      firstNamePtr = previousNamePtr = newNamePtr;
    }

    char *temp_buffer = malloc(get_charcount(first_input_buffer));
    strcpy(temp_buffer, first_input_buffer);
    newNamePtr->first = malloc(get_charcount(first_input_buffer));
    strcpy(newNamePtr->first, temp_buffer);


    realloc(temp_buffer, get_charcount(last_input_buffer));

    strcpy(temp_buffer, last_input_buffer);
    newNamePtr->last = malloc(get_charcount(last_input_buffer));
    strcpy(newNamePtr->last, temp_buffer);

    free(temp_buffer);
    temp_buffer = NULL;
  }
  previousNamePtr->next = NULL;
  previousNamePtr = NULL;
  free(first_input_buffer);
  free(last_input_buffer);
  first_input_buffer = NULL;
  last_input_buffer = NULL;
  fclose(fp);

  return firstNamePtr;
}

void print_name_list (Name *name)
{
  static int first_iteration = 1;
  if (first_iteration) 
  {
    printf("\nList of Names\n");
    printf("=============\n");
    first_iteration--;
  }
  printf("%s %s\n",name->first, name->last);
  if (name->next)
    print_name_list(name->next);
  else
    printf("\n");
}

void free_name_list (Name *name)
{
  if (name->next)
    free_name_list(name->next);
  free(name->first);
  free(name->last);
  name->first = NULL;
  name->last = NULL;
  name->next = NULL;
  free(name);
  name = NULL;
}

Answer 1

由于还没有人提到它，如果你使用 *scanf 来读取不受信任的输入字符串，你应该总是使用 最大字段宽度说明符。喜欢

scanf("%19s", str);

请注意，这指定了不包括终止 NUL 的最大字符串长度，因此在此示例中，str 应为 20 个字符长。

如果你不限制这样的 scanf 输入转换，在缓冲区溢出时，你不仅会得到未定义的行为，还会出现安全漏洞。

回到你关于动态增长缓冲区的问题。假设您正在读取一些由行组成的输入，并且每行最多可以有 78 个字符宽。在这种情况下，您知道每行的最大长度，但不知道整个输入的最大长度。一种常见的方法是分配一些默认空间，如果需要增加该空间，请将其增加 *2，这样就不需要多次 realloc()。

Answer 2

您是否开始阅读有关链表的内容？它可以帮助您拥有一个动态的结构。

您还可以检查数组和链表之间的区别。 char 指针可以是链表的成员，可以动态分配内存。

查看来自 stackoverflow 的 link 以获取更多信息。

Answer 3

您必须有一个最大长度的数组来获取输入 - 您不知道输入的长度。但是，您只需要一个该长度的数组。获得输入后，您可以获取它的长度并分配一个大小合适的数组来存储名称。

至于增加您的列表，您可以使用realloc 或当然使用链接列表。

Answer 4

一个非常简单的方法是根本不使用数组，而是使用链表：

这可以通过多种方式完成，但最简单的可能是修改 Name 结构如下：

typedef struct _Name Name;

struct _Name {
  char *first;
  char *last;
  Name *next;
};

使用 char * 而不是 char[] 将需要一些strcpying，但这实际上既不存在也不存在。要扩展数组，您现在可以一次简单地 malloc 这些元素；并适当设置下一个。

注意：当你创建新的尾部元素时，记得设置next为NULL。

Answer 5

没有办法在 C 中扩展数组。您所能做的就是分配更大的内存块并将项目复制过来。这就是 Python 在幕后所做的。

也无法确定数组的大小，因为它只存储项目而没有其他信息（Python 数组将长度存储在元素旁边。）您可以在数组末尾放置一个标记并计算元素在您点击标记之前，这就是字符串的工作方式（空字符 '\0' 是标记。）