End of File(Eof) of Standard Input Stream (Stdin)

End of File in stdin

so if there is NOTHING written, End of File, (EOF) is not returned automatically?

No, it's not. It should be sent by the user.

So is it that only the user can invoke EOF in stdin by pressing Ctrl+Z?

Yes, you can set the EOF indicator for stdin with a special key combination you can input in the console, for linux console that is Ctrl+D and for windows it's Ctrl+Z.

If so then what are some of the uses of EOF in stdin? I guess it tells the program to continue reading until the user user invokes end of file? is this it?

The use of it depends on whether you instruct the user to input the EOF explicitly or not, for example, I think python console will tell you something like Press Ctrl+D or type quit() to exit.

And EOF is not necessarily -1 it's a macro and you should always use it to test for the EOF indicator. And more importantly EOF is not a character, it's a special value that indicates that the End Of File indicator is set.

Also, getchar() is equivalent to fgetc(stdin).

End of File(EOF) of Standard input stream (stdin)

Speaking about EOF in stdin: when you redirect input from file, e.g.:

program <input.txt

the file already has an EOF, so this is not a problem. In console you can simulate EOF flag. In UNIX systems it is Ctrl+D, in Windows Ctrl+Z. When you type this in the console, program will behave like it has just reached end of input file.

Edit

According to a question asked by OP:

So does it means that stdin don't have EOF and we have to insert them manually using Ctrl+Z or Ctrl+D?

Actually -- yes. One may consider stdin (not redirected, but taken from the console) as infinite file -- no one can tell where does it end. The end of input file, where input ist stdin, must be told literally by Ctrl+D or Ctrl+Z.

setting input stream to return EOF repeatedly in loop

The stream's end-of-file flag is set when it reaches EOF. This is the flag that the feof() function tests.

If you want to read past this, you can use the clearerr() function. This clears both the error and EOF indicators (I don't think there's a way to clear just one of them).

int main(void)
{
    int input=0;

    while(input=getchar()) {              //TARGET
        printf("%d\n",input);
        if (feof(stdin) || ferror(stdin)) {
            clearerr(stdin);
        }
    }
}

Note that whether you actually can read anything after EOF is both system- and device-dependent. If stdin is a terminal or ordinary file, EOF is a temporary condition (the user can keep typing on the terminal after entering Ctl-d, and more data can be added to a file). But once you get to the end of a TCP stream, nothing can be added to it.

In python, how to check the end of standard input streams (sys.stdin) and do something special on that

for line in sys.stdin:
    do_whatever()
# End of stream!
do_whatever_else()

It's that simple.

When does feof(stdin) next to fgets(stdin) return true?

feof tests the stream’s end-of-file indicator and returns true (non-zero) iff the end-of-file indicator is set.

For regular files, attempting to read past the end of the file sets the end-of-file indicator. For terminals, a typical behavior is that when a program attempts to read from the terminal and gets no data, the end-of-file indicator is set. In Unix systems with default settings, a way to trigger this “no data, end-of-file behavior” is to press control-D at the beginning of a line or immediately after a prior control-D.

The reason this works is because control-D is used to mean “send pending data to the program immediately.” That is described further in this answer.

Thus, if you want to end input for a program, press control-D (and, if not at the beginning of a line, press it a second time).

For input from terminals, while this does cause an end-of-file indication, it does not actually end the input or close the stream. The program can clear the end-of-file indicator and keep reading. Even for regular files, the program could clear the end-of-file indicator, reset the file context to a different position, and continue reading.

How do I read input until EOF in Java for this program on SPOJ?

Standard input actually has no EOF, so you'll never see it. Your method #3 will work when reading from an actual file (or other stream) which does have an end.

(You may want to try to 'type' an EOF on the stdin (Ctrl-D or Ctrl-Z), which may or may not work, not sure.)

Take input until the end of file in python

you just have some simple syntactic/spelling issues:

while True:
        try:
            s=input()
            print("Do something")
        except EOFError:
            break

On Unix systems usually Ctrl+D is how you simulate an EOF from terminal

Stdin and EOF Behaviour under Windows console

You use Ctrl-Z to signal EOF. Your program behaves accordingly. But stdin will remain open. You can still 'close' stdin, but for your program only. Try this, and see the difference:

   while ((c = getchar()) != EOF)
      printf("%c", c);
   fclose(stdin); // <----------
   printf("Let's just check if we can still read from stdin, type a char: ");
   c = getchar();
   printf("\nYou entered: %c\n", c);

You will not get 'a' anymore, you will get EOF (-1).

Edit:

EOF is a macro definition in stdio.h, and is commonly equal to -1
To simulate EOF via terminal input, type the sequence: Enter-Cntrl-Z-Enter in the Windows console.
After EOF signal, the input stream remains open... Why? Because stdin is supposed to be always open. (One could use fclose(stdin) to close the stream, but that is a bad idea, since file handles can easily get messed up.)
^Z is not EOF, if you check for it's value it's 26 (Not -1).
Typing ^Z anywhere would flush stdin after that...