关于EOF和ÿ的困惑

Question

In my GCC on Windows, the value of EOF is -1 . And I notice that the value of 'ÿ' is also -1 . So I did the following experiment and I'm totally confused of the results.

int main() {
    
    int a = 'ÿ';
    if (a == EOF) {
        putchar('a');
        putchar(a);
    }

    char b = 'ÿ';
    if (b == EOF) {
        putchar('b');
        putchar(b);
    }

    putchar('\n');

    int c;
    if ((c = getchar()) != EOF) {
        putchar('c');
        putchar(c);
    }

    char d;
    if ((d = getchar()) != EOF) {
        putchar('d');
        putchar(d);
    }
}

The results are

aÿbÿ  // a == EOF b == EOF
ÿÿ    //My input for int c and char d
cÿ    // c != EOF

My questions are: 1. When I directly assign 'ÿ' to a variable, no matter the type is int or char, it equals to EOF . But when I assign 'ÿ' to int c from stdin, it turns out that c doesn't equal to EOF . What happened here? 2. How does the system distinguish between 'ÿ' and EOF if there's a 'ÿ' in the file?

Answer 1

'ÿ' is the character representation of number 255. Its value as char literal is -1 .

Both 255 and -1 have the same 8-bit representation ( 11111111 ), it depends if it is interpreted as a signed or unsigned value. char is signed, therefore its value as char is -1 .

When it is assigned to a char variable it is stored as is.
When it is assigned to an int variable, the value is promoted to int and this does not change its value, it is only represented using more bits (4 bytes).

Incidentally -1 is also the value of EOF (but you should always use the constant EOF in the code and never rely on its numeric value).

---

getchar() returns an int ; for 'ÿ' it returns 255.

When it is assigned to an int the value is preserved.

When it is assigned to a char , the behaviour is undefined (because the possible range of values for a char variable is -128 .. +127 ).
It seems that your compiler chooses to store the rightmost 8 bits of 255 into the char variable and, due to the fact that char is signed, the value is interpreted as -1 .

How does the system distinguish between 'ÿ' and EOF if there's a 'ÿ' in the file?

getchar() , fgetc() / getc() and other functions that read characters return int . This means they always return values between (and including) 0 and 255 when the succeed and EOF (that has a negative values) when there end of file is reached.

The value of EOF is negative, it cannot be confused with 'ÿ' .

Answer 2

A C program has an execution character set, and this determines how character literals are mapped to integer values.

It seems like your program is being compiled with iso-8859-1 as the execution character set. On my computer, the default for gcc is utf-8, where 'ÿ' maps to the "multi-character constant" 50111. With iso-8859-1, gcc maps it to -1. I have to use the flag -fexec-charset=iso-8859-1 to reproduce what you're seeing.

When you read from a file (or from stdin), you get whatever bytes the operating system gives you (interpreted as an unsigned character). The encoding of stdin and files is in general independent from the execution character set.

What you're observing is that the execution character set is iso-8859-1 mapped to the range -128 to 127 (rather than the usual 0 to 255), presumably with the rationale that char is signed on your compiler, so can represent every value in the execution character set. The encoding for stdin seems also to be iso-8859-1, except it uses the usual 0 to 255. In case (d) in your question, the value 255 is being assigned to a char (which is probably signed, from -128 to 127), and gcc is wrapping it.

Summary:

• (a) assigns -1 to a
• (b) assigns -1 to b
• (c) assigns 255 to c
• (d) converts 255 to a char , resulting in -1. This -1 is assigned to d .