c语言如何连续输入多组字符串

在C语言中，连续输入多组字符串的常用方法包括使用循环、使用数组、使用指针、使用动态内存分配。其中，使用循环和数组是最基础和常见的方法，但在需要更灵活的内存管理时，使用指针和动态内存分配可能更加适合。以下将详细讨论这些方法，并提供示例代码。

一、使用循环

使用循环是处理连续输入多组字符串的基本方法。它可以确保程序能够处理任意数量的输入组，并且在处理每一组输入时保持一致。

1.1、使用`scanf`和`gets`函数

#include <stdio.h>
int main() {
    int n;
    printf("Enter the number of strings: ");
    scanf("%d", &n);
    getchar(); // To consume the newline character left by scanf
    char str[100];
    for (int i = 0; i < n; i++) {
        printf("Enter string %d: ", i + 1);
        gets(str);
        printf("String %d is: %sn", i + 1, str);
    }
    return 0;
}

在上述代码中，scanf函数用于读取输入的字符串数量，getchar函数用于处理scanf遗留的换行符，然后通过一个for循环使用gets函数逐个读取字符串。

1.2、使用`fgets`函数

gets函数不安全，可能导致缓冲区溢出，推荐使用fgets函数。

#include <stdio.h>
int main() {
    int n;
    printf("Enter the number of strings: ");
    scanf("%d", &n);
    getchar(); // To consume the newline character left by scanf
    char str[100];
    for (int i = 0; i < n; i++) {
        printf("Enter string %d: ", i + 1);
        fgets(str, sizeof(str), stdin);
        // Remove trailing newline character
        str[strcspn(str, "n")] = 0;
        printf("String %d is: %sn", i + 1, str);
    }
    return 0;
}

二、使用数组

使用数组可以方便地存储多个字符串，并进行批量处理。

2.1、静态数组

#include <stdio.h>
int main() {
    int n;
    printf("Enter the number of strings: ");
    scanf("%d", &n);
    getchar(); // To consume the newline character left by scanf
    char str[n][100];
    for (int i = 0; i < n; i++) {
        printf("Enter string %d: ", i + 1);
        fgets(str[i], sizeof(str[i]), stdin);
        str[i][strcspn(str[i], "n")] = 0; // Remove trailing newline character
    }
    for (int i = 0; i < n; i++) {
        printf("String %d is: %sn", i + 1, str[i]);
    }
    return 0;
}

上述代码中，使用二维数组str存储多个字符串，每个字符串的最大长度为100。通过循环读取和显示每个字符串。

2.2、动态数组

动态数组可以在运行时根据需要分配内存，提供更灵活的内存管理。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n;
    printf("Enter the number of strings: ");
    scanf("%d", &n);
    getchar(); // To consume the newline character left by scanf
    char str = (char )malloc(n * sizeof(char *));
    for (int i = 0; i < n; i++) {
        str[i] = (char *)malloc(100 * sizeof(char));
        printf("Enter string %d: ", i + 1);
        fgets(str[i], 100, stdin);
        str[i][strcspn(str[i], "n")] = 0; // Remove trailing newline character
    }
    for (int i = 0; i < n; i++) {
        printf("String %d is: %sn", i + 1, str[i]);
    }
    for (int i = 0; i < n; i++) {
        free(str[i]);
    }
    free(str);
    return 0;
}

三、使用指针

使用指针可以更灵活地管理内存，尤其适合处理未知数量的字符串。

3.1、使用指针数组

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n;
    printf("Enter the number of strings: ");
    scanf("%d", &n);
    getchar(); // To consume the newline character left by scanf
    char str = (char )malloc(n * sizeof(char *));
    for (int i = 0; i < n; i++) {
        str[i] = (char *)malloc(100 * sizeof(char));
        printf("Enter string %d: ", i + 1);
        fgets(str[i], 100, stdin);
        str[i][strcspn(str[i], "n")] = 0; // Remove trailing newline character
    }
    for (int i = 0; i < n; i++) {
        printf("String %d is: %sn", i + 1, str[i]);
    }
    for (int i = 0; i < n; i++) {
        free(str[i]);
    }
    free(str);
    return 0;
}

四、使用动态内存分配

动态内存分配提供了灵活的内存管理方案，适合处理大规模和复杂的数据输入。

4.1、使用`malloc`和`realloc`函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
    int n = 0;
    int capacity = 2;
    char str = (char )malloc(capacity * sizeof(char *));
    char buffer[100];
    while (1) {
        printf("Enter a string (or 'exit' to stop): ");
        fgets(buffer, 100, stdin);
        buffer[strcspn(buffer, "n")] = 0; // Remove trailing newline character
        if (strcmp(buffer, "exit") == 0) {
            break;
        }
        if (n >= capacity) {
            capacity *= 2;
            str = (char )realloc(str, capacity * sizeof(char *));
        }
        str[n] = (char *)malloc((strlen(buffer) + 1) * sizeof(char));
        strcpy(str[n], buffer);
        n++;
    }
    for (int i = 0; i < n; i++) {
        printf("String %d is: %sn", i + 1, str[i]);
    }
    for (int i = 0; i < n; i++) {
        free(str[i]);
    }
    free(str);
    return 0;
}

上述代码中，使用malloc函数分配初始内存，并使用realloc函数根据需要动态调整内存大小。通过这种方法，可以处理任意数量的字符串输入。

五、总结

在C语言中，处理连续输入多组字符串有多种方法，包括使用循环、数组、指针和动态内存分配。每种方法都有其优缺点，选择合适的方法取决于具体需求和应用场景。

使用循环是最基础的方法，适合处理固定数量的字符串输入；使用数组可以方便地存储和管理多组字符串；使用指针提供了更灵活的内存管理方案；使用动态内存分配则适合处理大规模和复杂的数据输入。

在实际应用中，推荐根据具体需求选择合适的方法，并注意内存管理和安全性，确保程序的稳定性和可靠性。