c语言如何输入长度不定数组

要在C语言中输入长度不定的数组，可以使用动态内存分配、使用指针和递归等技术。最常用的方法是通过动态内存分配函数如malloc和realloc来动态调整数组的大小。以下是详细描述：

1. 动态内存分配、2. 使用指针、3. 递归

动态内存分配是处理长度不定数组的核心技术。通过malloc函数可以在运行时分配指定大小的内存空间，realloc函数则可以在需要时调整这块内存的大小。首先，我们需要了解如何使用这些函数，然后通过实例来展示如何实现长度不定数组的输入。

一、动态内存分配

1.1 动态内存分配基础

动态内存分配在C语言中是通过库函数malloc、calloc和realloc来实现的。这些函数都在stdlib.h头文件中定义。

malloc函数

void* malloc(size_t size);

malloc函数分配一块指定大小的内存空间，返回一个指向这块内存的指针。返回的内存未初始化。

calloc函数

void* calloc(size_t num, size_t size);

calloc函数分配一块包含num个元素的内存空间，每个元素的大小为size字节，并且初始化为零。

realloc函数

void* realloc(void* ptr, size_t new_size);

realloc函数调整之前分配的内存块的大小。ptr是一个指向先前通过malloc或calloc分配的内存的指针，new_size是新的大小。

1.2 动态内存分配示例

下面是一个简单的示例，展示如何使用malloc和realloc来实现一个长度不定的数组。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *array = NULL;
    int size = 0;
    int capacity = 1;
    int input;
    array = (int*)malloc(capacity * sizeof(int));
    if (array == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }
    printf("Enter numbers (negative number to end): n");
    while (scanf("%d", &input) && input >= 0) {
        if (size == capacity) {
            capacity *= 2;
            array = (int*)realloc(array, capacity * sizeof(int));
            if (array == NULL) {
                printf("Memory allocation failed!n");
                return 1;
            }
        }
        array[size++] = input;
    }
    printf("You entered: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("n");
    free(array);
    return 0;
}

在这个示例中，我们首先使用malloc分配了一个初始大小为1的内存空间。然后在用户输入数据时，检查当前数组是否已满，如果已满则使用realloc函数将数组的容量扩大一倍。最后，打印用户输入的所有数据并释放分配的内存。

二、使用指针

2.1 指针的基础知识

在C语言中，指针是一种特殊的数据类型，它存储的是内存地址。指针可以用来动态分配内存、访问数组元素和传递函数参数。

声明指针

int* ptr;

ptr是一个指向int类型数据的指针。

访问指针

int value = *ptr;

*ptr表示访问ptr指向的内存地址处的值。

2.2 指针与数组

数组名在C语言中可以看作是一个指向数组首元素的指针。因此，我们可以使用指针来访问数组元素。

int array[5] = {1, 2, 3, 4, 5};
int* ptr = array;
for (int i = 0; i < 5; i++) {
    printf("%d ", *(ptr + i));
}

在这个示例中，ptr指向数组array的首元素，通过*(ptr + i)可以访问数组的每个元素。

2.3 动态数组与指针

使用指针和动态内存分配，我们可以创建一个动态数组。上面的示例已经展示了如何实现一个长度不定的数组，这里再详细解释一下。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *array = NULL;
    int size = 0;
    int capacity = 1;
    int input;
    array = (int*)malloc(capacity * sizeof(int));
    if (array == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }
    printf("Enter numbers (negative number to end): n");
    while (scanf("%d", &input) && input >= 0) {
        if (size == capacity) {
            capacity *= 2;
            array = (int*)realloc(array, capacity * sizeof(int));
            if (array == NULL) {
                printf("Memory allocation failed!n");
                return 1;
            }
        }
        array[size++] = input;
    }
    printf("You entered: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("n");
    free(array);
    return 0;
}

在这个示例中，array是一个指向int类型数据的指针。我们使用malloc函数分配了一个初始大小为1的内存空间，然后在用户输入数据时，检查当前数组是否已满，如果已满则使用realloc函数将数组的容量扩大一倍。最后，打印用户输入的所有数据并释放分配的内存。

三、递归

3.1 递归的基础知识

递归是指在函数内部调用函数自身。递归函数必须有一个基准情况（base case），用于终止递归调用，否则会陷入无限递归。

递归示例

#include <stdio.h>
void countDown(int n) {
    if (n <= 0) {
        printf("Blast off!n");
        return;
    }
    printf("%dn", n);
    countDown(n - 1);
}
int main() {
    countDown(5);
    return 0;
}

在这个示例中，countDown函数是一个递归函数，它打印从n到0的数字，然后打印“Blast off!”。

3.2 使用递归输入长度不定数组

我们可以使用递归来实现一个长度不定的数组输入函数。在每次递归调用中，我们检查当前数组是否已满，如果已满则使用realloc函数将数组的容量扩大一倍，然后继续输入下一个数据。

#include <stdio.h>
#include <stdlib.h>
void inputArray(int array, int *size, int *capacity) {
    int input;
    if (scanf("%d", &input) && input >= 0) {
        if (*size == *capacity) {
            *capacity *= 2;
            *array = (int*)realloc(*array, *capacity * sizeof(int));
            if (*array == NULL) {
                printf("Memory allocation failed!n");
                exit(1);
            }
        }
        (*array)[(*size)++] = input;
        inputArray(array, size, capacity);
    }
}
int main() {
    int *array = NULL;
    int size = 0;
    int capacity = 1;
    array = (int*)malloc(capacity * sizeof(int));
    if (array == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }
    printf("Enter numbers (negative number to end): n");
    inputArray(&array, &size, &capacity);
    printf("You entered: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("n");
    free(array);
    return 0;
}

在这个示例中，inputArray函数是一个递归函数，用于输入长度不定的数组。每次递归调用时，我们检查当前数组是否已满，如果已满则使用realloc函数将数组的容量扩大一倍，然后继续输入下一个数据。最后，打印用户输入的所有数据并释放分配的内存。

四、总结

在C语言中，处理长度不定的数组通常需要使用动态内存分配技术。通过malloc和realloc函数可以在运行时分配和调整内存的大小，使用指针可以访问和操作动态分配的内存。此外，递归技术也可以用于实现长度不定的数组输入。理解并掌握这些技术，对于编写灵活和高效的C语言程序是非常重要的。

在实际开发过程中，选择适合的项目管理工具也非常重要。推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile，它们能够帮助团队更好地管理和跟踪项目进度，提高工作效率。