C语言新手关于gets()/puts()替代方案及printf/scanf适用性的问询

Hey there, let's walk through all your questions about C string I/O functions—since you're a beginner, it's totally normal to get confused between old docs and modern compiler warnings. Let's break this down clearly:

为什么gets()被废弃，puts()的小细节 #

First off, let's address the elephant in the room: gets() is extremely dangerous and has been removed from the C standard since C11. The problem is that it doesn't check how much input it's reading—if you pass a 10-character buffer but the user types 100 characters, gets() will write past the buffer's end, causing buffer overflow. This leads to crashes, undefined behavior, or even security vulnerabilities.

As for puts(), it's still technically usable, but it has a quirk: it automatically appends a newline character (\n) to the end of your string when printing. If that's what you want, great—otherwise, you'll need to use printf() instead to avoid the extra newline.

替代函数：fgets()、getc()、getchar()的具体用途 #

These are the safe, modern alternatives you should learn. Let's go one by one:

• fgets(): This is the direct, safe replacement for gets(). Its prototype is char *fgets(char *str, int num, FILE *stream).

  • It reads up to num-1 characters from the specified stream (use stdin for keyboard input), stopping when it hits a newline or EOF.
  • It automatically adds a null terminator (\0) to the end of your string.
  • Important: It includes the newline character (\n) in the string if the input fits. If you don't want that, you can strip it out with strcspn():

    char buffer[100];
    fgets(buffer, sizeof(buffer), stdin);
    // Remove the trailing newline
    buffer[strcspn(buffer, "\n")] = '\0';
    

• getchar(): This function reads a single character from standard input (stdin). It returns an int (not char) because it needs to return EOF (a value of -1) to signal the end of input.

  • Use it when you need to handle input one character at a time—like validating a single user choice, or manually building a string. Example:

    int input_char;
    // Read until newline or EOF
    while ((input_char = getchar()) != '\n' && input_char != EOF) {
        // Process each character here
        printf("You typed: %c\n", (char)input_char);
    }
    

• getc(): This is similar to getchar(), but it works with any file stream (not just stdin). For example, getc(stdin) does the exact same thing as getchar(), but you can also use getc(file_pointer) to read a character from a file. In fact, getchar() is usually defined as a macro: #define getchar() getc(stdin).

能用printf()、scanf()替代gets()、puts()吗？ #

Absolutely, but with some caveats:

• Replacing puts(): This is straightforward. puts("Hello") is exactly equivalent to printf("Hello\n"). If you don't want the automatic newline, just use printf("Hello") instead—printf() gives you full control over formatting, which makes it more flexible than puts().

• Replacing gets(): scanf() can work, but it's not ideal for all cases:

  • The default %s format specifier stops reading when it hits any whitespace (space, newline, tab). So if the user types "Hello World", scanf("%s", buffer) will only read "Hello" and leave " World" in the input buffer.
  • To read a full line including spaces, you can use %[^\n] (which means "read everything until a newline"). But you must add a length limit to avoid buffer overflow, just like with fgets(). Example:

    char buffer[100];
    // First, clear any leftover newline from previous input
    getchar();
    // Read up to 99 characters (leaving space for the null terminator)
    scanf("%99[^\n]", buffer);
    

  • Even with this, scanf() is less robust than fgets() because it's easier to run into issues with leftover characters in the input buffer. For most cases, fgets() is the safer choice.

Is scanf() suitable for string processing? #

Yes, but it has strict limitations:

• Use %s for simple, whitespace-separated strings (like single words). It's great for cases where you know the input won't have spaces.
• For strings with spaces, use %[^\n] only with a length limit—otherwise you're back to the same buffer overflow risk as gets().
• Always be mindful of leftover characters in the input buffer. For example, if you use scanf("%d", &num) to read an integer, the newline the user pressed will stay in the buffer, which can mess up subsequent string reads. You'll need to clear it with getchar() or fgets() before proceeding.
• For complex string parsing (like splitting a line into multiple values), it's often better to read the entire line with fgets() first, then use sscanf() to parse it. This avoids most of the input buffer issues.

内容的提问来源于stack exchange，提问作者Lixor