C语言动态数组创建与扩容技巧

C语言中创建动态数组，关键在于使用malloc、calloc或realloc函数在堆上分配内存。动态数组的优势在于其大小可以在程序运行时根据需要进行调整，这对于处理未知数据量的情况非常有用。然而，也需要小心处理内存管理，避免内存泄漏和悬挂指针。

使用malloc、calloc、realloc函数创建动态数组并进行内存管理。

如何使用malloc创建动态数组？

malloc函数用于分配指定大小的内存块。要创建一个动态数组，首先需要确定数组元素的类型和数量，然后将它们相乘得到所需的总内存大小。例如，创建一个存储int类型数据的动态数组：

#include 
#include 

int main() {
  int n = 10; // 数组大小
  int *arr = (int*)malloc(n * sizeof(int)); // 分配内存

  if (arr == NULL) {
    printf("内存分配失败！\n");
    return 1;
  }

  // 使用数组
  for (int i = 0; i < n; i++) {
    arr[i] = i * 2;
    printf("%d ", arr[i]);
  }
  printf("\n");

  free(arr); // 释放内存
  arr = NULL; // 防止悬挂指针

  return 0;
}

这段代码首先包含了必要的头文件，然后定义了数组的大小n。使用malloc分配了n * sizeof(int)字节的内存，并将返回的指针强制转换为int*类型。务必检查malloc的返回值是否为NULL，以确保内存分配成功。使用完数组后，使用free释放内存，并将指针设置为NULL，防止出现悬挂指针。

calloc与malloc的区别是什么？

calloc函数与malloc类似，但它会将分配的内存初始化为零。calloc接受两个参数：元素数量和每个元素的大小。例如：

#include 
#include 

int main() {
  int n = 10;
  int *arr = (int*)calloc(n, sizeof(int)); // 分配并初始化内存

  if (arr == NULL) {
    printf("内存分配失败！\n");
    return 1;
  }

  // 使用数组
  for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]); // 初始值为0
  }
  printf("\n");

  free(arr);
  arr = NULL;

  return 0;
}

使用calloc可以确保数组在使用前所有元素都被初始化为零，这在某些情况下可以避免未定义行为。

如何使用realloc动态调整数组大小？

realloc函数用于重新分配先前分配的内存块的大小。这对于动态数组非常有用，因为可以在运行时根据需要增加或减少数组的大小。例如：

#include 
#include 

int main() {
  int n = 5;
  int *arr = (int*)malloc(n * sizeof(int));

  if (arr == NULL) {
    printf("内存分配失败！\n");
    return 1;
  }

  // 初始赋值
  for (int i = 0; i < n; i++) {
    arr[i] = i;
  }

  // 扩展数组大小
  n = 10;
  arr = (int*)realloc(arr, n * sizeof(int));

  if (arr == NULL) {
    printf("内存重新分配失败！\n");
    return 1;
  }

  // 使用扩展后的数组
  for (int i = 5; i < n; i++) {
    arr[i] = i * 2;
  }

  for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
  }
  printf("\n");

  free(arr);
  arr = NULL;

  return 0;
}

realloc尝试在原内存块的基础上扩展内存，如果原内存块后面有足够的空间，则直接扩展；否则，realloc会分配一个新的内存块，并将原内存块的内容复制到新的内存块中，然后释放原内存块。务必检查realloc的返回值，以确保内存重新分配成功。

动态数组的内存泄漏如何避免？

内存泄漏是指程序在分配内存后，未能及时释放不再使用的内存，导致系统可用内存逐渐减少。为了避免动态数组的内存泄漏，必须确保每次使用malloc、calloc或realloc分配的内存，最终都使用free释放。例如：

#include 
#include 

void allocate_memory() {
  int *ptr = (int*)malloc(100 * sizeof(int));
  // ... 使用 ptr ...
  free(ptr); // 释放内存
  ptr = NULL; // 防止悬挂指针
}

int main() {
  allocate_memory();
  return 0;
}

在函数结束前，确保释放了所有分配的内存。将指针设置为NULL可以防止悬挂指针，即指针指向已释放的内存。

动态数组扩容时的数据复制效率问题？

当使用realloc扩展动态数组时，如果需要分配新的内存块并将原有数据复制到新的内存块，这可能会导致性能问题，特别是当数组非常大时。为了提高效率，可以考虑以下策略：

1. 预留空间： 在初始分配内存时，分配比当前需要的稍大的空间，以便在需要扩展时，可以直接使用预留的空间，而无需重新分配内存和复制数据。
2. 指数增长： 每次扩展数组时，将数组大小增加一倍或按指数增长，而不是每次只增加一个元素。这样可以减少重新分配内存的次数。

例如：

#include 
#include 

int main() {
  int capacity = 10; // 初始容量
  int size = 0; // 当前元素数量
  int *arr = (int*)malloc(capacity * sizeof(int));

  if (arr == NULL) {
    printf("内存分配失败！\n");
    return 1;
  }

  // 添加元素
  for (int i = 0; i < 20; i++) {
    if (size == capacity) {
      // 扩展数组
      capacity *= 2;
      arr = (int*)realloc(arr, capacity * sizeof(int));
      if (arr == NULL) {
        printf("内存重新分配失败！\n");
        return 1;
      }
    }
    arr[size++] = i;
  }

  // 打印数组
  for (int i = 0; i < size; i++) {
    printf("%d ", arr[i]);
  }
  printf("\n");

  free(arr);
  arr = NULL;

  return 0;
}

在这个例子中，数组的容量初始为10，每次需要扩展时，容量翻倍。这样可以显著减少realloc的调用次数。

如何处理动态数组的越界访问？

动态数组的越界访问是一个常见的错误，可能导致程序崩溃或产生不可预测的结果。为了避免越界访问，必须确保在访问数组元素时，索引值在有效范围内。可以使用断言（assert）来检查索引值是否有效。例如：

#include 
#include 
#include 

int main() {
  int n = 10;
  int *arr = (int*)malloc(n * sizeof(int));

  if (arr == NULL) {
    printf("内存分配失败！\n");
    return 1;
  }

  // 安全访问数组
  for (int i = 0; i < n; i++) {
    assert(i >= 0 && i < n); // 检查索引是否有效
    arr[i] = i * 2;
    printf("%d ", arr[i]);
  }
  printf("\n");

  free(arr);
  arr = NULL;

  return 0;
}

assert宏会在运行时检查条件是否为真。如果条件为假，程序会终止并显示错误信息。在发布版本的代码中，可以通过定义NDEBUG宏来禁用assert。

动态数组与静态数组的适用场景？

静态数组在编译时确定大小，而动态数组在运行时确定大小。静态数组的优点是访问速度快，内存分配在栈上，管理简单。动态数组的优点是大小可以灵活调整，适用于处理未知数据量的情况。

选择使用静态数组还是动态数组，取决于具体的应用场景。如果数组的大小在编译时已知且不会改变，则静态数组是一个不错的选择。如果数组的大小在运行时才能确定，或者需要根据需要动态调整，则动态数组是更好的选择。