C File Handling - Tricky MCQ

fopen() returns a FILE* pointer on success and NULL on failure. Common failure reasons: file doesn't exist (for reading), permission denied, disk full, invalid path. Always check if fopen() returned NULL before using the file pointer to avoid segmentation faults. Use perror() or strerror(errno) to get error details after fopen() failure.

fgetc() is a function, getc() is a macro (may evaluate argument multiple times), getchar() is equivalent to getc(stdin). All return int (not char) to accommodate EOF (-1) and all char values (0-255). Since getc() is a macro, avoid expressions with side effects as arguments. fgetc() is safer when stream argument has side effects. They all return EOF on end-of-file or error.

The file position indicator tracks the current read/write location. fseek() moves it, ftell() returns current position, rewind() sets to beginning. For binary files, seeking is precise (byte offsets). For text files, only seeking to position 0 (beginning) or position from ftell() is reliable due to newline translation differences. fseek() with SEEK_END is not portable for text files.

fread() and fwrite() perform binary I/O - they read/write raw bytes without interpretation. fprintf() and fscanf() perform formatted I/O - they convert between binary and text representations. Binary I/O is faster, preserves exact values (important for floats), and produces smaller files. Formatted I/O creates human-readable files but is slower and may lose precision. Use binary for data structures, formatted for config files.

stdin, stdout, and stderr are pre-opened FILE* streams automatically available to programs. stdin: standard input (keyboard), stdout: standard output (screen), stderr: standard error (screen). stdout is typically line-buffered when connected to terminal, stderr is unbuffered for immediate error reporting. They can be redirected: "program > file" redirects stdout, "2> file" redirects stderr. Use stderr for error messages to separate from normal output.

File buffering stores data in memory buffers before writing to disk or after reading from disk. This reduces expensive system calls (read()/write()) by batching operations. Default buffering: fully buffered for files, line-buffered for stdout to terminal, unbuffered for stderr. setbuf() and setvbuf() control buffering mode (full, line, none) and buffer size. fflush() forces buffer write. Buffering improves performance but can cause data loss on crash if not flushed.

feof() returns non-zero only after a read attempt has reached end-of-file. It doesn't predict the future. Read functions (fgetc(), fread(), etc.) return special values (EOF, 0, etc.) when they fail. The correct pattern: attempt to read, check if read succeeded, if failed, use feof() to distinguish between end-of-file and error, or ferror() for error details. Never use feof() as loop condition - it leads to off-by-one errors.

You can open the same file multiple times with fopen(), creating independent FILE* streams. However, this leads to problems: 1) Buffering causes data written through one stream to not be visible to another until flushed, 2) Overlapping reads/writes cause undefined behavior, 3) File position indicators are independent, causing confusion. The C standard says behavior is undefined for most operations on the same file through different streams. Use a single stream or proper file locking.

Temporary files store intermediate data. tmpfile() creates unnamed temporary file in binary update mode (w+b), automatically deleted when closed or program exits. tmpnam() generates unique filename but has race condition (another process could create file with same name before you do). mkstemp() (POSIX) creates file with unique name atomically, returns file descriptor. Always use tmpfile() or mkstemp() for security; avoid tmpnam().

ferror() tests the error indicator for a specific FILE* stream, returning non-zero if error occurred on that stream. errno is a global integer variable set by failed system/library calls to indicate error type. Use ferror() after failed stream operation to check if it was an error (vs EOF). Use perror() or strerror(errno) to get human-readable error message. Clear errors with clearerr() to reuse stream after error.

Sequential access reads/writes data in order from start to end. Random access (direct access) allows jumping to any position using file position indicator. fseek() moves to specific position, ftell() returns current position, rewind() goes to beginning. Binary files support precise random access with byte offsets. Text files have limited random access due to newline translation; only seeking to positions obtained from ftell() or to beginning is reliable.

File descriptor (int, like 0,1,2 for stdin,stdout,stderr) is low-level OS handle returned by open(). FILE* is high-level stream structure from stdio.h with buffering, error handling, formatted I/O. Standard library uses descriptors internally but adds features. fileno() gets descriptor from FILE*; fdopen() creates FILE* from descriptor. Use descriptors for low-level control (non-blocking I/O, file locking), FILE* for buffered/formatted I/O. Always close both consistently.

Return is complete elements read; short return on error/EOF.

Text mode may translate newline on some systems.

Text streams can have encoding transformations; ftell on text may be misleading.

Removing open file behavior varies by OS.

Seeking end then ftell commonly yields size for binary files.

feof is set after failed read due to EOF; not predictive before read.

tmpfile opens a temporary binary file removed on fclose or exit.

fgetc returns unsigned char converted to int or EOF macro.

NULL buffer with setbuf makes stream unbuffered when supported.

Short fwrite indicates error or incomplete write.

perror outputs user message and strerror(errno) to stderr.

fclose flushes unwritten data; explicit fflush can surface errors earlier.