c语言如何读入未知个数的数字

C语言如何读入未知个数的数字，使用动态内存分配、链表数据结构、文件输入输出

在C语言中，读入未知个数的数字可以通过多种方法来实现，使用动态内存分配、链表数据结构、文件输入输出，这三种方法都具有各自的优点和适用场景。本文将详细介绍这三种方法，并提供相应的代码示例。

一、使用动态内存分配

动态内存分配是指在程序运行时动态地分配内存空间。对于未知个数的数字，可以先分配一个初始大小的数组，并在需要时重新分配更大的内存空间。

动态内存分配的实现

在C语言中，可以使用malloc、realloc等函数来实现动态内存分配。以下是一个示例代码，展示了如何使用动态内存分配来读入未知个数的数字：

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *numbers = NULL;
    int size = 0;
    int capacity = 10;
    int num;
    numbers = (int *)malloc(capacity * sizeof(int));
    if (numbers == NULL) {
        fprintf(stderr, "Memory allocation failedn");
        return 1;
    }
    printf("Enter numbers (end input with a non-numeric character):n");
    while (scanf("%d", &num) == 1) {
        if (size >= capacity) {
            capacity *= 2;
            numbers = (int *)realloc(numbers, capacity * sizeof(int));
            if (numbers == NULL) {
                fprintf(stderr, "Memory reallocation failedn");
                return 1;
            }
        }
        numbers[size++] = num;
    }
    printf("You entered %d numbers:n", size);
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("n");
    free(numbers);
    return 0;
}

在这个示例中，程序首先分配一个初始大小为10的数组，当数组容量不足时，使用realloc函数重新分配更大的内存空间。输入结束后，程序输出所有读入的数字。

二、使用链表数据结构

链表是一种动态数据结构，可以方便地存储未知个数的元素。使用链表存储数字，可以避免频繁的内存分配和重新分配。

链表的实现

以下是一个示例代码，展示了如何使用链表来读入未知个数的数字：

#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, "Memory allocation failedn");
        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;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->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("Enter numbers (end input with a non-numeric character):n");
    while (scanf("%d", &num) == 1) {
        append(&head, num);
    }
    printf("You entered:n");
    printList(head);
    freeList(head);
    return 0;
}

在这个示例中，程序使用链表来存储读入的数字。createNode函数用于创建新节点，append函数用于将新节点添加到链表的末尾，printList函数用于输出链表中的所有数字，freeList函数用于释放链表所占用的内存。

三、使用文件输入输出

如果需要从文件中读入未知个数的数字，可以使用文件输入输出操作。文件输入输出操作可以方便地处理大规模的数据，并且可以将程序的输入和输出分离。

文件输入输出的实现

以下是一个示例代码，展示了如何从文件中读入未知个数的数字，并使用动态内存分配来存储这些数字：

#include <stdio.h>
#include <stdlib.h>
int main() {
    FILE *file;
    int *numbers = NULL;
    int size = 0;
    int capacity = 10;
    int num;
    file = fopen("numbers.txt", "r");
    if (file == NULL) {
        fprintf(stderr, "Could not open filen");
        return 1;
    }
    numbers = (int *)malloc(capacity * sizeof(int));
    if (numbers == NULL) {
        fprintf(stderr, "Memory allocation failedn");
        fclose(file);
        return 1;
    }
    while (fscanf(file, "%d", &num) == 1) {
        if (size >= capacity) {
            capacity *= 2;
            numbers = (int *)realloc(numbers, capacity * sizeof(int));
            if (numbers == NULL) {
                fprintf(stderr, "Memory reallocation failedn");
                fclose(file);
                return 1;
            }
        }
        numbers[size++] = num;
    }
    fclose(file);
    printf("You read %d numbers from file:n", size);
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("n");
    free(numbers);
    return 0;
}

在这个示例中，程序从名为numbers.txt的文件中读入数字，并使用动态内存分配来存储这些数字。输入结束后，程序输出所有读入的数字。

四、总结

在C语言中，读入未知个数的数字可以通过多种方法来实现，主要包括使用动态内存分配、链表数据结构、文件输入输出。每种方法都有其优点和适用场景，开发者可以根据具体需求选择合适的方法。

动态内存分配：适用于内存空间较为有限的场景，通过malloc和realloc函数动态调整数组大小。
链表数据结构：适用于频繁插入和删除操作的场景，通过链表节点的动态创建和连接实现。
文件输入输出：适用于需要处理大量数据的场景，通过文件读写操作实现数据的存储和读取。

无论选择哪种方法，都需要注意内存管理，避免内存泄漏和非法访问。同时，可以结合使用项目管理系统如研发项目管理系统PingCode和通用项目管理软件Worktile，提高开发效率和项目管理水平。