This section describes functions for performing character-oriented input. These narrow streams functions are declared in the header file `stdio.h' and the wide character functions are declared in `wchar.h'.
These functions return an int or wint_t value (for narrow
and wide stream functions respectively) that is either a character of
input, or the special value EOF/WEOF (usually -1). For
the narrow stream functions it is important to store the result of these
functions in a variable of type int instead of char, even
when you plan to use it only as a character. Storing EOF in a
char variable truncates its value to the size of a character, so
that it is no longer distinguishable from the valid character
`(char) -1'. So always use an int for the result of
getc and friends, and check for EOF after the call; once
you've verified that the result is not EOF, you can be sure that
it will fit in a `char' variable without loss of information.
unsigned char from
the stream stream and returns its value, converted to an
int. If an end-of-file condition or read error occurs,
EOF is returned instead.
WEOF is returned instead.
fgetc_unlocked function is equivalent to the fgetc
function except that it does not implicitly lock the stream.
fgetwc_unlocked function is equivalent to the fgetwc
function except that it does not implicitly lock the stream.
This function is a GNU extension.
fgetc, except that it is permissible (and
typical) for it to be implemented as a macro that evaluates the
stream argument more than once. getc is often highly
optimized, so it is usually the best function to use to read a single
character.
fgetwc, except that it is permissible for it to
be implemented as a macro that evaluates the stream argument more
than once. getwc can be highly optimized, so it is usually the
best function to use to read a single wide character.
getc_unlocked function is equivalent to the getc
function except that it does not implicitly lock the stream.
getwc_unlocked function is equivalent to the getwc
function except that it does not implicitly lock the stream.
This function is a GNU extension.
getchar function is equivalent to getc with stdin
as the value of the stream argument.
getwchar function is equivalent to getwc with stdin
as the value of the stream argument.
getchar_unlocked function is equivalent to the getchar
function except that it does not implicitly lock the stream.
getwchar_unlocked function is equivalent to the getwchar
function except that it does not implicitly lock the stream.
This function is a GNU extension.
Here is an example of a function that does input using fgetc. It
would work just as well using getc instead, or using
getchar () instead of fgetc (stdin). The code would
also work the same for the wide character stream functions.
int
y_or_n_p (const char *question)
{
fputs (question, stdout);
while (1)
{
int c, answer;
/* Write a space to separate answer from question. */
fputc (' ', stdout);
/* Read the first character of the line.
This should be the answer character, but might not be. */
c = tolower (fgetc (stdin));
answer = c;
/* Discard rest of input line. */
while (c != '\n' && c != EOF)
c = fgetc (stdin);
/* Obey the answer if it was valid. */
if (answer == 'y')
return 1;
if (answer == 'n')
return 0;
/* Answer was invalid: ask for valid answer. */
fputs ("Please answer y or n:", stdout);
}
}
int) from stream.
It's provided for compatibility with SVID. We recommend you use
fread instead (see section Block Input/Output). Unlike getc,
any int value could be a valid result. getw returns
EOF when it encounters end-of-file or an error, but there is no
way to distinguish this from an input word with value -1.
Go to the first, previous, next, last section, table of contents.