<stdio.h>_IOFBF
· _IOLBF · _IONBF · BUFSIZ · EOF · FILE · FILENAME_MAX
· FOPEN_MAX
· L_tmpnam
· NULL · SEEK_CUR · SEEK_END · SEEK_SET · TMP_MAX · clearerr · fclose · feof · ferror · fflush · fgetc · fgetpos · fgets · fopen · fpos_t · fprintf · fputc · fputs · fread · freopen · fscanf · fseek · fsetpos · ftell · fwrite · getc · getchar · gets · perror · printf · putc · putchar · puts · remove · rename · rewind · scanf · setbuf · setvbuf · size_t · sprintf · sscanf · stderr · stdin · stdout · tmpfile · tmpnam · ungetc · vfprintf · vprintf · vsprintf
#define _IOFBF <integer constant expression>
#define _IOLBF <integer constant expression>
#define _IONBF <integer constant expression>
#define BUFSIZ <integer constant expression >= 256>
#define EOF <integer constant expression < 0>
typedef o-type FILE;
#define FILENAME_MAX <integer constant expression > 0>
#define FOPEN_MAX <integer constant expression >= 8>
#define L_tmpnam <integer constant expression > 0>
#define NULL <either 0, 0L, or (void *)0> [0 in C++]
#define SEEK_CUR <integer constant expression>
#define SEEK_END <integer constant expression>
#define SEEK_SET <integer constant expression>
#define TMP_MAX <integer constant expression >= 25>
void clearerr(FILE *stream);
int fclose(FILE *stream);
int feof(FILE *stream);
int ferror(FILE *stream);
int fflush(FILE *stream);
int fgetc(FILE *stream);
int fgetpos(FILE *stream, fpos_t *pos);
char *fgets(char *s, int n, FILE *stream);
FILE *fopen(const char *filename, const char *mode);
typedef o-type fpos_t;
int fprintf(FILE *stream, const char *format, ...);
int fputc(int c, FILE *stream);
int fputs(const char *s, FILE *stream);
size_t fread(void *ptr,
size_t size, size_t nelem, FILE *stream);
FILE *freopen(const char *filename, const char *mode,
FILE *stream);
int fscanf(FILE *stream, const char *format, ...);
int fseek(FILE *stream, long offset, int mode);
int fsetpos(FILE *stream, const fpos_t *pos);
long ftell(FILE *stream);
size_t fwrite(const void *ptr, size_t size, size_t nelem,
FILE *stream);
int getc(FILE *stream);
int getchar(void);
char *gets(char *s);
void perror(const char *s);
int printf(const char *format, ...);
int putc(int c, FILE *stream);
int putchar(int c);
int puts(const char *s);
int remove(const char *filename);
int rename(const char *old, const char *new);
void rewind(FILE *stream);
int scanf(const char *format, ...);
void setbuf(FILE *stream, char *buf);
int setvbuf(FILE *stream, char *buf, int mode,
size_t size);
typedef ui-type size_t;
int sprintf(char *s, const char *format, ...);
int sscanf(const char *s, const char *format, ...);
#define stderr <pointer to FILE rvalue>
#define stdin <pointer to FILE rvalue>
#define stdout <pointer to FILE rvalue>
FILE *tmpfile(void)
char *tmpnam(char *s);
int ungetc(int c, FILE *stream);
int vfprintf(FILE *stream, const char *format,
va_list ap);
int vprintf(const char *format, va_list ap);
int vsprintf(char *s, const char *format, va_list ap);
Include the standard header <stdio.h>
so that you can perform input and output operations on streams
and files.
_IOFBF#define _IOFBF <integer constant expression>
The macro yields the value of the mode argument
to setvbuf
to indicate full buffering.
(Flush the stream buffer only when it fills.)
_IOLBF#define _IOLBF <integer constant expression>
The macro yields the value of the mode argument
to setvbuf
to indicate line buffering.
(Flush the stream buffer at the end of a text line.)
_IONBF#define _IONBF <integer constant expression>
The macro yields the value of the mode argument
to setvbuf
to indicate no buffering.
(Flush the stream buffer at the end of each write operation.)
BUFSIZ#define BUFSIZ <integer constant expression >= 256>
The macro yields the size of the stream buffer used by setbuf.
EOF#define EOF <integer constant expression < 0>
The macro yields the return value used to signal the end of a stream or to report an error condition.
FILEtypedef o-type FILE;
The type is an object type o-type that
stores all control
information for a stream. The functions fopen and freopen
allocate all FILE objects used by the read and write
functions.
FILENAME_MAX#define FILENAME_MAX <integer constant expression > 0>
The macro yields the maximum size array of characters that you must provide to hold a filename.
FOPEN_MAX#define FOPEN_MAX <integer constant expression >= 8>
The macro yields the maximum number of files that the target
environment permits to be simultaneously open (including stderr,
stdin,
and stdout).
L_tmpnam#define L_tmpnam <integer constant expression > 0>
The macro yields the number of characters that the target
environment requires for representing temporary filenames created
by tmpnam.
NULL#define NULL <either 0, 0L, or (void *)0> [0 in C++]
The macro yields a null pointer constant that is usable as an address constant expression.
SEEK_CUR#define SEEK_CUR <integer constant expression>
The macro yields the value of the mode argument
to fseek
to indicate seeking relative to the current file-position
indicator.
SEEK_END#define SEEK_END <integer constant expression>
The macro yields the value of the mode argument
to fseek
to indicate seeking relative to the end of the file.
SEEK_SET#define SEEK_SET <integer constant expression>
The macro yields the value of the mode argument
to fseek
to indicate seeking relative to the beginning of the file.
TMP_MAX#define TMP_MAX <integer constant expression >= 25>
The macro yields the minimum number of distinct filenames
created by the function tmpnam.
clearerrvoid clearerr(FILE *stream);
The function clears the end-of-file and error indicators for
the stream stream.
fcloseint fclose(FILE *stream);
The function closes the file associated with the stream stream.
It returns zero if successful; otherwise, it returns EOF. fclose
writes any buffered output to the file, deallocates the stream
buffer if it was automatically allocated, and removes the
association between the stream and the file. Do not use the value
of stream in subsequent expressions.
feofint feof(FILE *stream);
The function returns a nonzero value if the end-of-file
indicator is set for the stream stream.
ferrorint ferror(FILE *stream);
The function returns a nonzero value if the error indicator is
set for the stream stream.
fflushint fflush(FILE *stream);
The function writes any buffered output to the file associated
with the stream stream and returns zero if
successful; otherwise, it returns EOF. If stream
is a null pointer, fflush writes any buffered output
to all files opened for output.
fgetcint fgetc(FILE *stream);
The function reads the next character c (if
present) from the input stream stream, advances the
file-position indicator (if defined), and returns (int)(unsigned
char)c. If the function sets either the end-of-file
indicator or the error indicator, it returns EOF.
fgetposint fgetpos(FILE *stream, fpos_t *pos);
The function stores the file-position indicator for the stream
stream in *pos and returns zero if
successful; otherwise, the function stores a positive value in errno and returns a
nonzero value.
fgetschar *fgets(char *s, int n, FILE *stream);
The function reads characters from the input stream stream
and stores them in successive elements of the array beginning at s
and continuing until it stores n-1 characters,
stores an NL character, or sets the
end-of-file or error indicators. If fgets stores any
characters, it concludes by storing a null character in the next
element of the array. It returns s if it stores any
characters and it has not set the error indicator for the stream;
otherwise, it returns a null pointer. If it sets the error
indicator, the array contents are indeterminate.
fopenFILE *fopen(const char *filename, const char *mode);
The function opens the file with the filename filename,
associates it with a stream, and returns a pointer to the object
controlling the stream. If the open fails, it returns a null
pointer. The initial characters of mode determine
how the program manipulates
the stream and whether it interprets the stream as text or
binary. The initial characters must be one of the following
sequences:
"r" -- to open an existing
text file for reading "w" -- to create a text
file or to open and truncate an existing text file, for
writing "a" -- to create a text
file or to open an existing text file, for writing. The
file-position indicator is positioned at the end of the
file before each write "rb" -- to open an existing
binary file for reading "wb" -- to create a binary
file or to open and truncate an existing binary file, for
writing "ab" -- to create a binary
file or to open an existing binary file, for writing. The
file-position indicator is positioned at the end of the
file (possibly after arbitrary null byte padding) before
each write "r+" -- to open an existing
text file for reading and writing "w+" -- to create a text
file or to open and truncate an existing text file, for
reading and writing "a+" -- to create a text
file or to open an existing text file, for reading and
writing. The file-position indicator is positioned at the
end of the file before each write "r+b" or "rb+"
-- to open an existing binary file for reading and
writing "w+b" or "wb+"
-- to create a binary file or to open and truncate an
existing binary file, for reading and writing "a+b" or "ab+"
-- to create a binary file or to open an existing binary
file, for reading and writing. The file-position
indicator is positioned at the end of the file (possibly
after arbitrary null byte padding) before each write If you open a file for both reading and writing, the target environment can open a binary file instead of a text file. If the file is not interactive, the stream is fully buffered.
fpos_ttypedef o-type fpos_t;
The type is an object type o-type of an
object that you declare to hold the value of a file-position
indicator stored by fsetpos and
accessed by fgetpos.
fprintfint fprintf(FILE *stream, const char *format, ...);
The function generates
formatted text, under the control of the format format
and any additional arguments, and writes each generated character
to the stream stream. It returns the number of
characters generated, or it returns a negative value if the
function sets the error indicator for the stream.
fputcint fputc(int c, FILE *stream);
The function writes the character (unsigned char)c
to the output stream stream, advances the
file-position indicator (if defined), and returns (int)(unsigned
char)c. If the function sets the error indicator for the
stream, it returns EOF.
fputsint fputs(const char *s, FILE *stream);
The function accesses characters from the C string s
and writes them to the output stream stream. The
function does not write the terminating null character. It
returns a nonnegative value if it has not set the error
indicator; otherwise, it returns EOF.
freadsize_t fread(void *ptr, size_t size, size_t nelem,
FILE *stream);
The function reads characters from the input stream stream
and stores them in successive elements of the array whose first
element has the address (char *)ptr until the
function stores size*nelem characters or sets the
end-of-file or error indicator. It returns n/size,
where n is the number of characters it read. If n
is not a multiple of size, the value stored in the
last element is indeterminate. If the function sets the error
indicator, the file-position indicator is indeterminate.
freopenFILE *freopen(const char *filename, const char *mode,
FILE *stream);
The function closes the file associated with the stream stream
(as if by calling fclose);
then it opens the file with the filename filename
and associates the file with the stream stream (as
if by calling fopen(filename, mode)). It
returns stream if the open is successful; otherwise,
it returns a null pointer.
fscanfint fscanf(FILE *stream, const char *format, ...);
The function scans
formatted text, under the control of the format format
and any additional arguments. It obtains each scanned character
from the stream stream. It returns the number of
input items matched and assigned, or it returns EOF if
the function does not store values before it sets the end-of-file
or error indicator for the stream.
fseekint fseek(FILE *stream, long offset, int mode);
The function sets the file-position indicator for the stream stream
(as specified by offset and mode),
clears the end-of-file indicator for the stream, and returns zero
if successful.
For a binary
stream, offset is a signed offset in bytes:
mode has the value SEEK_SET, fseek
adds offset to the file-position indicator
for the beginning of the file. mode has the value SEEK_CUR, fseek
adds offset to the current file-position
indicator. mode has the value SEEK_END, fseek
adds offset to the file-position indicator
for the end of the file (possibly after arbitrary null
character padding). fseek sets the file-position indicator to the
result of this addition.
For a text stream:
mode has the value SEEK_SET, fseek
sets the file-position indicator to the value encoded in offset,
which is either a value returned by an earlier successful
call to ftell
or zero to indicate the beginning of the file. mode has the value SEEK_CUR
and offset is zero, fseek
leaves the file-position indicator at its current value. mode has the value SEEK_END
and offset is zero, fseek sets
the file-position indicator to indicate the end of the
file. The function defines no other combination of argument values.
fsetposint fsetpos(FILE *stream, const fpos_t *pos);
The function sets the file-position indicator for the stream stream
to the value stored in *pos, clears the end-of-file
indicator for the stream, and returns zero if successful.
Otherwise, the function stores a positive value in errno and returns a
nonzero value.
ftelllong ftell(FILE *stream);
The function returns an encoded form of the file-position
indicator for the stream stream or stores a positive
value in errno and
returns the value -1. For a binary file, a successful return
value gives the number of bytes from the beginning of the file.
For a text file, target environments can vary on the
representation and range of encoded file-position indicator
values.
fwritesize_t fwrite(const void *ptr, size_t size, size_t nelem,
FILE *stream);
The function writes characters to the output stream stream,
accessing values from successive elements of the array whose
first element has the address (char *)ptr until the
function writes size*nelem characters or sets the
error indicator. It returns n/size, where n
is the number of characters it wrote. If the function sets the
error indicator, the file-position indicator is indeterminate.
getcint getc(FILE *stream);
The function has the same effect as fgetc(stream) except that a
macro version of getc can evaluate stream
more than once.
getcharint getchar(void);
The function has the same effect as fgetc(stdin), reading a
character from the stream stdin
getschar *gets(char *s);
The function reads characters from the stream stdin
and stores them in successive elements of the array whose first
element has the address s until the function reads
an NL character (which is not stored) or sets
the end-of-file or error indicator. If gets reads
any characters, it concludes by storing a null character in the
next element of the array. It returns s if it reads
any characters and has not set the error indicator for the
stream; otherwise, it returns a null pointer. If it sets the
error indicator, the array contents are indeterminate. The number
of characters that gets reads and stores cannot be
limited. Use fgets
instead.
perrorvoid perror(const char *s);
The function writes a line of text to the stream stderr.
If s is not a null pointer, the function first
writes the C string
s (as if by calling fputs(s, stderr)), followed
by a colon (:) and a space. It
then writes the same message C string that is
returned by strerror(errno),
converting the value stored in errno,
followed by an NL.
printfint printf(const char *format, ...);
The function generates
formatted text, under the control of the format format
and any additional arguments, and writes each generated character
to the stream stdout.
It returns the number of characters generated, or it returns a
negative value if the function sets the error indicator for the
stream.
putcint putc(int c, FILE *stream);
The function has the same effect as fputc(c, stream) except
that a macro version of putc can evaluate stream
more than once.
putcharint putchar(int c);
The function has the same effect as fputc(c, stdout), writing a
character to the stream stdout.
putsint puts(const char *s);
The function accesses characters from the C string s
and writes them to the stream stdout. The function
writes an NL character to the stream in place
of the terminating null character. It returns a nonnegative value
if it has not set the error indicator; otherwise, it returns EOF.
removeint remove(const char *filename);
The function removes the file with the filename filename
and returns zero if successful. If the file is open when you
remove it, the result is implementation defined. After you remove
it, you cannot open it as an existing file.
renameint rename(const char *old, const char *new);
The function renames the file with the filename old
to have the filename new and returns zero if
successful. If a file with the filename new already
exists, the result is implementation defined. After you rename
it, you cannot open the file with the filename old.
rewindvoid rewind(FILE *stream);
The function calls fseek(stream, 0L, SEEK_SET)
and then clears the error indicator for the stream stream.
scanfint scanf(const char *format, ...);
The function scans
formatted text, under the control of the format format
and any additional arguments. It obtains each scanned character
from the stream stdin.
It returns the number of input items matched and assigned, or it
returns EOF
if the function does not store values before it sets the
end-of-file or error indicators for the stream.
setbufvoid setbuf(FILE *stream, char *buf);
If buf is not a null pointer, the function calls setvbuf(stream,
buf, __IOFBF, BUFSIZ), specifying full buffering with _IOFBF
and a buffer size of BUFSIZ characters.
Otherwise, the function calls setvbuf(stream, 0, _IONBF,
BUFSIZ), specifying no buffering with _IONBF.
setvbufint setvbuf(FILE *stream, char *buf, int mode,
size_t size);
The function sets the buffering mode for the stream stream
according to buf, mode, and size.
It returns zero if successful. If buf is not a null
pointer, then buf is the address of the first
element of an array of char of size size that
can be used as the stream buffer. Otherwise, setvbuf
can allocate a stream buffer that is freed when the file is
closed. For mode you must supply one of the
following values:
_IOFBF
-- to indicate full buffering _IOLBF
-- to indicate line buffering _IONBF
-- to indicate no buffering You must call setvbuf after you call fopen
to associate a file with that stream and before you call a
library function that performs any other operation on the stream.
size_ttypedef ui-type size_t;
The type is the unsigned integer type ui-type
of an object that you declare to store the result of the sizeof
operator.
sprintfint sprintf(char *s, const char *format, ...);
The function generates
formatted text, under the control of the format format
and any additional arguments, and stores each generated character
in successive locations of the array object whose first element
has the address s. The function concludes by storing
a null character in the next location of the array. It returns
the number of characters generated -- not including the null
character.
sscanfint sscanf(const char *s, const char *format, ...);
The function scans
formatted text, under the control of the format format
and any additional arguments. It accesses each scanned character
from successive locations of the array object whose first element
has the address s. It returns the number of items
matched and assigned, or it returns EOF if the function
does not store values before it accesses a null character from
the array.
stderr#define stderr <pointer to FILE rvalue>
The macro yields a pointer to the object that controls the standard error output stream.
stdin#define stdin <pointer to FILE rvalue>
The macro yields a pointer to the object that controls the standard input stream.
stdout#define stdout <pointer to FILE rvalue>
The macro yields a pointer to the object that controls the standard output stream.
tmpfileFILE *tmpfile(void)
The function creates a temporary binary file with the filename
temp-name and then has the same effect as
calling fopen(temp-name,
"wb+"). The file temp-name
is removed when the program closes it, either by calling fclose
explicitly or at normal program termination. The filename temp-name
does not conflict with any filenames that you create. If the open
is successful, the function returns a pointer to the object
controlling the stream; otherwise, it returns a null pointer.
tmpnamchar *tmpnam(char *s);
The function creates a unique filename temp-name
and returns a pointer to the filename. If s is not a
null pointer, then s must be the address of the
first element of an array at least of size L_tmpnam. The
function stores temp-name in the array and
returns s. Otherwise, if s is a null
pointer, the function stores temp-name in a
static-duration array and returns the address of its first
element. Subsequent calls to tmpnam can alter the
values stored in this array.
The function returns unique filenames for each of the first TMP_MAX
times it is called, after which its behavior is implementation
defined. The filename temp-name does not
conflict with any filenames that you create.
ungetcint ungetc(int c, FILE *stream);
If c is not equal to EOF, the function
stores (unsigned char)c in the object whose address
is stream and clears the end-of-file indicator. If c
equals EOF
or the store cannot occur, the function returns EOF;
otherwise, it returns (unsigned char)c. A subsequent
library function call that reads a character from the stream stream
obtains this stored value, which is then forgotten.
Thus, you can effectively push back a character to a stream after reading a character. (You need not push back the same character that you read.) An implementation can let you push back additional characters before you read the first one. You read the characters in reverse order of pushing them back to the stream. You cannot portably:
ftell
for a text file that has a character currently pushed
back A call to the functions fseek, fsetpos,
or rewind
for the stream causes the stream to forget any pushed-back
characters. For a binary stream, the file-position indicator is
decremented for each character that is pushed back.
vfprintfint vfprintf(FILE *stream, const char *format,
va_list ap);
The function generates
formatted text, under the control of the format format
and any additional arguments, and writes each generated character
to the stream stream. It returns the number of
characters generated, or it returns a negative value if the
function sets the error indicator for the stream.
The function accesses additional arguments by using the
context information designated by ap. The program
must execute the macro va_start
before it calls the function, and then execute the macro va_end after the
function returns.
vprintfint vprintf(const char *format, va_list ap);
The function generates
formatted text, under the control of the format format
and any additional arguments, and writes each generated character
to the stream stdout.
It returns the number of characters generated, or a negative
value if the function sets the error indicator for the stream.
The function accesses additional arguments by using the
context information designated by ap. The program
must execute the macro va_start
before it calls the function, and then execute the macro va_end after the
function returns.
vsprintfint vsprintf(char *s, const char *format, va_list ap);
The function generates
formatted text, under the control of the format format
and any additional arguments, and stores each generated character
in successive locations of the array object whose first element
has the address s. The function concludes by storing
a null character in the next location of the array. It returns
the number of characters generated -- not including the null
character.
The function accesses additional arguments by using the
context information designated by ap. The program
must execute the macro va_start
before it calls the function, and then execute the macro va_end after the
function returns.
See also the Table of Contents .
Copyright © 1989-1996 by P.J. Plauger and Jim Brodie. All rights reserved.