关于《C程序设计语言》第1.9节get_line函数换行符处理逻辑的疑问

Great question—this is a common point of confusion when first working through The C Programming Language, so let's unpack it step by step.

First, let's recap what the original get_line function does: it reads a line of input (up to lim-1 characters to leave space for the null terminator), stores it in the s array, returns the length of the line (including the newline if it fit), and ensures the array is null-terminated.

Why the Separate if (c == '\n') Check? #

The key here lies in how the for loop is structured:

for (i = 0, l = 0; (c = getchar()) != EOF && c != '\n'; ++i) {
    if (i < lim - 1) s[l++] = c;
}

This loop only runs when the character read is neither EOF nor a newline ('\n'). As soon as getchar() returns '\n' or EOF, the loop condition fails, and we exit the loop—without ever processing that newline character inside the loop body.

The newline is still stored in the variable c, though! So we need to handle it separately: if we have remaining space in the array (l < lim - 1), we add the newline to s and increment the length counter l. Then we add the null terminator and return the length.

Can We Integrate This Into the For Loop? #

Yes, technically we could restructure the loop to handle the newline inside, but it would require changing the loop's logic. For example:

int get_line(char s[], int lim) {
    int c, i, l;
    for (i = 0, l = 0; (c = getchar()) != EOF; ++i) {
        // Check if we hit a newline first
        if (c == '\n') {
            if (l < lim - 1) s[l++] = c;
            break; // Exit loop after handling newline
        }
        // Handle regular characters
        if (i < lim - 1) s[l++] = c;
    }
    s[l] = '\0';
    return l;
}

This version works similarly, but the original K&R approach has a few subtle advantages:

• Logical separation: The loop focuses solely on reading non-newline, non-EOF characters, while the separate check handles the special case of the newline. This makes the code easier to parse at a glance.
• Consistency in counting: The loop's i variable counts every character read (even those that don't fit in the array), and keeping the newline handling outside maintains this consistency without extra conditional logic inside the loop.

Edge Cases to Consider #

The separate check also cleanly handles edge cases:

1. Line exceeds buffer size: If the input line is longer than lim-1, the loop will read all characters up to the newline but only store lim-1 of them. The newline check will then skip adding the newline (since l is already at lim-1), which is correct—we can't store the newline without overflowing the buffer.
2. EOF without a newline: If the input ends with EOF (no trailing newline), the separate check simply doesn't run, and we add the null terminator as usual.

内容的提问来源于stack exchange，提问作者Rein Van Imschoot