C 语言中向数组添加元素的函数183

在 C 语言中，数组是一种数据结构，用于存储相同数据类型的一组元素。数组的大小在编译时固定，因此不能动态地添加或删除元素。然而，有几种方法可以模拟向数组添加元素的行为，包括使用指针、动态内存分配和链表。

使用指针

使用指针是最简单的方法之一，它是通过递增指向数组最后一个元素的指针来模拟向数组添加元素。以下代码演示了如何使用指针向数组中添加元素：
```c
#include
int main() {
int arr[] = {1, 2, 3, 4, 5};
int *p = arr;
*p++ = 6; // 添加元素 6
*p++ = 7; // 添加元素 7
for (int i = 0; i < 7; i++) {
printf("%d ", arr[i]);
}
return 0;
}
```

在这个例子中，数组 arr 包含 5 个元素，指针 p 被初始化为指向数组的第一个元素。然后使用自增运算符 p++ 将指针递增，并对指针解引用将元素 6 添加到数组中。这个过程重复一次，将元素 7 添加到数组中。最后，使用 for 循环打印修改后的数组。

使用动态内存分配

动态内存分配允许在运行时分配和释放内存。通过使用 malloc() 和 realloc() 函数，可以动态地增加数组的大小并向其中添加元素。以下代码演示了如何使用动态内存分配向数组中添加元素：
```c
#include
int main() {
int *arr = (int *)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
arr[i] = i + 1;
}
int *new_arr = (int *)realloc(arr, 7 * sizeof(int));
if (new_arr != NULL) {
new_arr[5] = 6;
new_arr[6] = 7;
arr = new_arr;
} else {
// 内存分配失败，处理错误
}
for (int i = 0; i < 7; i++) {
printf("%d ", arr[i]);
}
free(arr);
return 0;
}
```

在这个例子中，arr 被初始化为指向一个动态分配的数组，其中包含 5 个元素。然后使用 for 循环将元素添加到数组中。接下来，使用 realloc() 函数将数组的大小增加到 7 个元素。如果内存分配成功，则将 arr 指向新分配的数组，并将元素 6 和 7 添加到数组中。最后，使用 for 循环打印修改后的数组，并释放动态分配的内存。

使用链表

链表是一种数据结构，它由一系列连接在一起的节点组成，每个节点都包含数据和指向下一个节点的指针。通过使用链表，可以动态地向数组中添加元素，而无需担心数组大小的限制。以下代码演示了如何使用链表向数组中添加元素：
```c
#include
#include
struct node {
int data;
struct node *next;
};
int main() {
struct node *head = NULL;
struct node *current = NULL;
for (int i = 1; i data = i;
new_node->next = NULL;
if (head == NULL) {
head = new_node;
} else {
current->next = new_node;
}
current = new_node;
}
// 添加元素 6 和 7
struct node *new_node1 = (struct node *)malloc(sizeof(struct node));
new_node1->data = 6;
new_node1->next = NULL;
current->next = new_node1;
struct node *new_node2 = (struct node *)malloc(sizeof(struct node));
new_node2->data = 7;
new_node2->next = NULL;
new_node1->next = new_node2;
// 遍历链表并打印元素
current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
// 释放链表中的所有节点
current = head;
while (current != NULL) {
struct node *next = current->next;
free(current);
current = next;
}
return 0;
}
```

在这个例子中，使用链表来模拟数组。head 指向链表的第一个节点，current 指向当前正在处理的节点。for 循环将元素 1 到 5 添加到链表中。然后，添加元素 6 和 7，并更新链表指针以指向新添加的节点。最后，使用 while 循环遍历链表并打印元素，然后释放链表中的所有节点。

这三种方法各有优缺点。使用指针是最简单的方法，但它可能会导致数组越界错误。使用动态内存分配可以动态地增加数组的大小，但需要小心内存管理。使用链表可以实现更灵活的数组实现，但比前两种方法开销更大。

具体使用哪种方法取决于应用程序的特定需求。对于较小的数组，使用指针可能是一种可行的选择。对于需要动态增加数组大小的情况，动态内存分配是一种更好的选择。对于需要灵活和可扩展的数组实现的情况，链表可能是最佳选择。

2025-02-05

---

上一篇：求 K 的函数在 C 语言中的实现

下一篇：GCC 输出 C 语言