C语言中输入数量不定的数字的多种实现方法

C语言中输入数量不定的数字的多种实现方法

在C语言中，输入数量不定的数字可以通过动态内存分配、链表、数组等多种方法实现。最常用的方法包括动态数组、链表、使用标志符号来停止输入。其中，动态数组是一种高效且常用的方式。动态数组不仅可以灵活调整大小，还能有效管理内存。

一、动态数组

动态数组是指在程序运行期间可以动态调整大小的数组。在C语言中，动态数组的实现一般需要用到malloc、realloc和free函数。

1.1 初始化和使用

动态数组的初始化通常通过malloc函数实现。初始分配一个较小的内存块，然后根据需要通过realloc函数动态调整数组的大小。

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

int main() {
    int *array = NULL;
    int size = 0;
    int capacity = 2;  // 初始容量
    int num;
    array = (int*)malloc(capacity * sizeof(int));
    if (array == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return 1;
    }
    printf("请输入数字，输入-1结束：\n");
    while (scanf("%d", &num) && num != -1) {
        if (size == capacity) {
            capacity *= 2;
            array = (int*)realloc(array, capacity * sizeof(int));
            if (array == NULL) {
                fprintf(stderr, "内存重新分配失败\n");
                return 1;
            }
        }
        array[size++] = num;
    }
    printf("输入的数字是：\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
    free(array);
    return 0;
}

上述代码通过动态调整数组的大小，实现了输入数量不定的数字。初始容量设置为2，当数组满时，容量翻倍。

1.2 内存管理

内存管理是动态数组的关键。使用malloc和realloc函数进行内存分配和重新分配，使用free函数释放内存。

array = (int*)malloc(capacity * sizeof(int));
if (array == NULL) {
    fprintf(stderr, "内存分配失败\n");
    return 1;
}

在分配内存后，一定要检查是否成功。如果分配失败，程序应立即返回或采取相应的错误处理措施。

二、链表

链表是一种数据结构，适用于需要频繁插入和删除操作的场景。链表中的每个节点都包含一个数据域和一个指向下一个节点的指针。

2.1 单向链表

单向链表是最基本的链表形式。在C语言中，可以通过定义结构体实现单向链表。

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void append(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}

void printList(Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    Node* head = NULL;
    int num;
    printf("请输入数字，输入-1结束：\n");
    while (scanf("%d", &num) && num != -1) {
        append(&head, num);
    }
    printf("输入的数字是：\n");
    printList(head);
    freeList(head);
    return 0;
}

上述代码通过定义结构体和链表操作函数，实现了一个基本的单向链表。可以通过append函数向链表末尾添加节点。

2.2 内存管理

链表的内存管理相对简单。每次创建新节点时，分配内存；遍历链表时，释放内存。

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

创建新节点时，检查内存分配是否成功。如果失败，程序应立即退出或采取相应的错误处理措施。

三、使用标志符号停止输入

有时，使用特定的标志符号（如负数、特定字符）来停止输入是一种简单有效的方法。这种方法适用于数组或链表。

3.1 数组实现

#include <stdio.h>
#define MAX_SIZE 100

int main() {
    int array[MAX_SIZE];
    int size = 0;
    int num;
    printf("请输入数字，输入-1结束：\n");
    while (scanf("%d", &num) && num != -1) {
        if (size < MAX_SIZE) {
            array[size++] = num;
        } else {
            printf("数组已满\n");
            break;
        }
    }
    printf("输入的数字是：\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
    return 0;
}

上述代码使用数组和标志符号实现了输入数量不定的数字。数组容量固定为MAX_SIZE，输入-1结束输入。

四、内存管理最佳实践

无论使用动态数组还是链表，内存管理都是关键。以下是一些最佳实践：

4.1 检查内存分配结果

每次调用malloc、realloc或calloc函数后，都应检查返回的指针是否为NULL。

array = (int*)malloc(capacity * sizeof(int));
if (array == NULL) {
    fprintf(stderr, "内存分配失败\n");
    return 1;
}

4.2 释放内存

在程序结束前，确保释放所有动态分配的内存，避免内存泄漏。

free(array);

对于链表，遍历整个链表并释放每个节点的内存。

void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

4.3 使用智能指针（高级）

在更高层次的C++编程中，可以使用智能指针（如std::unique_ptr和std::shared_ptr）来自动管理内存。但在C语言中，需要手动管理内存。

五、总结

在C语言中，实现输入数量不定的数字可以通过动态数组、链表、使用标志符号来停止输入等多种方法。动态数组是高效且常用的方法，链表适用于需要频繁插入和删除操作的场景，使用标志符号则是一种简单有效的方法。无论采用哪种方法，内存管理都是关键，确保检查内存分配结果并释放内存以避免内存泄漏。

此外，如果你正在从事项目管理工作，可以使用研发项目管理系统PingCode和通用项目管理软件Worktile来提高效率。