File Basics in C

•Introduction
•What are Files?
•File Types in C
•File Pointer (FILE *)
•Opening Files - fopen()
•File Opening Modes
•Closing Files - fclose()
•Checking File Operations
•File Handle and Streams
•Standard Streams
•File Operations Workflow
•Common Pitfalls
•Best Practices
•Summary

Introduction

File handling is one of the most important aspects of programming. It allows programs to:

•Store data permanently - Data survives after program termination
•Process large datasets - Work with data too large for memory
•Share information - Exchange data between programs
•Maintain records - Create logs, configurations, databases
•Read external data - Process files created by other applications

C provides a comprehensive set of functions for file operations through the standard I/O library (<stdio.h>).

What are Files?

Definition

A file is a collection of related data stored on a secondary storage device (like a hard disk, SSD, or flash drive) with a unique name.

File Characteristics

┌────────────────────────────────────────────────────────────┐
│                        FILE                                │
├────────────────────────────────────────────────────────────┤
│  Name       : data.txt                                     │
│  Location   : /home/user/documents/                        │
│  Size       : 1024 bytes                                   │
│  Type       : Text file                                    │
│  Created    : 2024-01-15 10:30:00                         │
│  Modified   : 2024-01-20 15:45:00                         │
│  Permissions: Read, Write                                  │
└────────────────────────────────────────────────────────────┘

Why Use Files?

Aspect	Without Files	With Files
Data Persistence	Lost when program ends	Saved permanently
Data Size	Limited by RAM	Limited by disk space
Data Sharing	Difficult	Easy to share
Data Processing	All at once	Can process in chunks
Program State	Lost on restart	Can be restored

File Types in C

C distinguishes between two main types of files:

1. Text Files

•Store data as human-readable characters
•Each line typically ends with a newline character (\n)
•Data is stored as ASCII/UTF-8 characters
•Can be viewed with any text editor
•Slightly larger size due to character encoding

Example content of a text file:
┌────────────────────────────────────────┐
│ Hello, World!                          │
│ This is line 2.                        │
│ Number: 42                             │
└────────────────────────────────────────┘

Characteristics:

•Portable across different systems
•Easy to read and edit
•Slower to process
•Newline conversion (CR/LF) may occur

2. Binary Files

•Store data in raw binary format
•Exact memory representation of data
•Cannot be read with text editors (appears garbled)
•More compact and efficient
•Faster to read/write

Example binary representation:
┌────────────────────────────────────────┐
│ 48 65 6C 6C 6F 00 2A 00 00 00         │
│ (Hello + null + 42 as integer)         │
└────────────────────────────────────────┘

Characteristics:

•More efficient storage
•Faster read/write operations
•Not human-readable
•May not be portable between systems

Comparison

Feature	Text File	Binary File
Readability	Human-readable	Machine-readable
Size	Larger	Smaller
Speed	Slower	Faster
Portability	Better	System-dependent
Data Types	Character only	Any data type
Editing	Easy	Requires special tools
Extension	.txt, .csv, .c	.bin, .dat, .exe

File Pointer (FILE *)

The FILE Structure

In C, file operations use a file pointer of type FILE *. The FILE structure is defined in <stdio.h> and contains information about the file being accessed.

#include <stdio.h>

FILE *fp;  // Declare a file pointer

What FILE Contains (Conceptual)

┌─────────────────────────────────────────────────────────────┐
│                     FILE Structure                          │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐                                        │
│  │ Buffer Pointer  │ → Points to I/O buffer                 │
│  ├─────────────────┤                                        │
│  │ Buffer Size     │ → Size of the buffer                   │
│  ├─────────────────┤                                        │
│  │ Buffer Count    │ → Bytes remaining in buffer            │
│  ├─────────────────┤                                        │
│  │ File Descriptor │ → OS-level file handle                 │
│  ├─────────────────┤                                        │
│  │ Flags           │ → Read/Write/EOF/Error status          │
│  ├─────────────────┤                                        │
│  │ File Position   │ → Current position in file             │
│  └─────────────────┘                                        │
└─────────────────────────────────────────────────────────────┘

Important Points

•Never access FILE members directly - Always use library functions
•FILE * is opaque - Implementation details are hidden
•Initialize to NULL - Good practice to initialize file pointers
•Check for NULL - Always verify fopen() succeeded

FILE *fp = NULL;  // Good practice: initialize to NULL

fp = fopen("file.txt", "r");
if (fp == NULL) {
    // Handle error
    printf("Error: Cannot open file\n");
}

Opening Files - fopen()

Syntax

FILE *fopen(const char *filename, const char *mode);

Parameters

Parameter	Description
`filename`	Name of the file (with optional path)
`mode`	String specifying how to open the file

Return Value

•Success: Returns a pointer to FILE structure
•Failure: Returns NULL

Basic Usage

#include <stdio.h>

int main() {
    FILE *fp;

    // Open file for reading
    fp = fopen("myfile.txt", "r");

    if (fp == NULL) {
        printf("Error: Could not open file\n");
        return 1;
    }

    printf("File opened successfully!\n");

    // ... perform file operations ...

    fclose(fp);  // Always close the file
    return 0;
}

File Paths

// Current directory
fp = fopen("data.txt", "r");

// Relative path
fp = fopen("../data/input.txt", "r");
fp = fopen("subfolder/file.txt", "w");

// Absolute path (Linux/Mac)
fp = fopen("/home/user/documents/file.txt", "r");

// Absolute path (Windows)
fp = fopen("C:\\Users\\user\\Documents\\file.txt", "r");
// Or with forward slashes (works in Windows too)
fp = fopen("C:/Users/user/Documents/file.txt", "r");

File Opening Modes

Text Mode Options

Mode	Description	File Exists	File Doesn't Exist
`"r"`	Read only	Opens file	Returns NULL
`"w"`	Write only	Truncates to 0	Creates new file
`"a"`	Append only	Opens, position at end	Creates new file
`"r+"`	Read and write	Opens file	Returns NULL
`"w+"`	Read and write	Truncates to 0	Creates new file
`"a+"`	Read and append	Opens file	Creates new file

Binary Mode Options

Add b to the mode string for binary files:

Mode	Description
`"rb"`	Read binary
`"wb"`	Write binary
`"ab"`	Append binary
`"rb+"` or `"r+b"`	Read and write binary
`"wb+"` or `"w+b"`	Read and write binary (truncate)
`"ab+"` or `"a+b"`	Read and append binary

Mode Behavior Visual

Mode "r" (Read):
┌─────────────────────────────────────┐
│ existing content stays unchanged    │
│ ^                                   │
│ Position starts at beginning        │
└─────────────────────────────────────┘
Cannot write, only read.

Mode "w" (Write):
┌─────────────────────────────────────┐
│ (file is emptied/created)           │
│ ^                                   │
│ Position starts at beginning        │
└─────────────────────────────────────┘
Previous content is LOST!

Mode "a" (Append):
┌─────────────────────────────────────┐
│ existing content preserved          │
│                                    ^│
│ Position always at end for writing  │
└─────────────────────────────────────┘
New content added at end.

Mode "r+" (Read/Write):
┌─────────────────────────────────────┐
│ existing content stays              │
│ ^                                   │
│ Can read and write anywhere         │
└─────────────────────────────────────┘
Must call fseek() between read/write.

Mode "w+" (Read/Write, truncate):
┌─────────────────────────────────────┐
│ (file is emptied/created)           │
│ ^                                   │
│ Can read and write                  │
└─────────────────────────────────────┘
Previous content is LOST!

Mode "a+" (Read/Append):
┌─────────────────────────────────────┐
│ existing content preserved          │
│ ^                                   │
│ Can read from start, write at end   │
└─────────────────────────────────────┘
Writes always go to end.

Choosing the Right Mode

Decision Tree:
                    ┌─────────────────────┐
                    │ What operation?     │
                    └─────────┬───────────┘
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
         ┌────────┐      ┌────────┐      ┌────────┐
         │ Read   │      │ Write  │      │ Both   │
         └───┬────┘      └───┬────┘      └───┬────┘
             │               │               │
    ┌────────┴────────┐     │      ┌────────┴────────┐
    ▼                 ▼     │      ▼                 ▼
"r" or "rb"    File must   │   Preserve        Truncate
   exist       exist?      │   content?        content?
                           │      │                │
              ┌────────────┴┐     ▼                ▼
              ▼             ▼  "r+"/rb+"       "w+"/wb+"
         Create new    Truncate
         or append?    existing?
              │             │
        ┌─────┴─────┐      ▼
        ▼           ▼   "w"/"wb"
    "a"/"ab"   "w"/"wb"

Closing Files - fclose()

Syntax

int fclose(FILE *stream);

Return Value

•Success: Returns 0
•Failure: Returns EOF (typically -1)

Why Close Files?

•Flush Buffers: Ensures all data is written to disk
•Release Resources: Frees file handle and memory
•Prevent Data Loss: Unsaved buffer data may be lost
•Avoid File Limits: Systems limit open files
•Allow Other Access: Release locks on the file

Basic Usage

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "w");

    if (fp == NULL) {
        return 1;
    }

    fprintf(fp, "Hello, World!\n");

    // Close the file
    if (fclose(fp) != 0) {
        printf("Error closing file\n");
        return 1;
    }

    // Set pointer to NULL after closing (good practice)
    fp = NULL;

    return 0;
}

Common Mistakes with fclose()

// WRONG: Using file after closing
FILE *fp = fopen("test.txt", "r");
fclose(fp);
fgetc(fp);  // UNDEFINED BEHAVIOR!

// WRONG: Closing NULL pointer
FILE *fp = fopen("nonexistent.txt", "r");  // Returns NULL
fclose(fp);  // UNDEFINED BEHAVIOR!

// WRONG: Closing same file twice
FILE *fp = fopen("test.txt", "r");
fclose(fp);
fclose(fp);  // UNDEFINED BEHAVIOR!

// CORRECT approach:
FILE *fp = fopen("test.txt", "r");
if (fp != NULL) {
    // ... use file ...
    fclose(fp);
    fp = NULL;  // Prevent accidental reuse
}

Checking File Operations

Error Checking Pattern

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main() {
    FILE *fp;
    const char *filename = "data.txt";

    // Open file
    fp = fopen(filename, "r");

    if (fp == NULL) {
        // Method 1: Simple message
        printf("Error: Cannot open '%s'\n", filename);

        // Method 2: Using perror (prints system error message)
        perror("fopen failed");

        // Method 3: Using strerror
        printf("Error: %s\n", strerror(errno));

        return 1;
    }

    printf("File opened successfully\n");

    // Close file
    if (fclose(fp) == EOF) {
        perror("fclose failed");
        return 1;
    }

    return 0;
}

Common errno Values for File Operations

Error	Value	Description
ENOENT	2	No such file or directory
EACCES	13	Permission denied
EEXIST	17	File exists (when creating)
EISDIR	21	Is a directory
EMFILE	24	Too many open files
ENOSPC	28	No space left on device
EROFS	30	Read-only file system

Using ferror() and feof()

#include <stdio.h>

void check_file_status(FILE *fp) {
    if (feof(fp)) {
        printf("End of file reached\n");
    }

    if (ferror(fp)) {
        printf("An error occurred\n");
        clearerr(fp);  // Clear error indicator
    }
}

File Handle and Streams

Buffering Concept

┌──────────────────────────────────────────────────────────────────┐
│                      Buffered I/O                                │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Program                Buffer                 Disk             │
│   ┌─────┐              ┌───────┐              ┌─────┐           │
│   │     │   write()    │       │   flush      │     │           │
│   │     │ ──────────► │ ##### │ ──────────► │     │           │
│   │     │              │ ##### │              │     │           │
│   │     │   read()     │       │   fill       │     │           │
│   │     │ ◄────────── │ ##### │ ◄────────── │     │           │
│   └─────┘              └───────┘              └─────┘           │
│                                                                  │
│   Data is collected in buffer before being written to disk.     │
│   This reduces the number of slow disk operations.              │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

Buffer Types

•
Fully Buffered: Data written when buffer is full
- •Default for files
- •Most efficient for files
•
Line Buffered: Data written when newline is encountered
- •Default for terminals (stdout when connected to terminal)
- •Good for interactive output
•
Unbuffered: Data written immediately
- •Used for stderr
- •Slower but immediate

Controlling Buffering

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");

    // Set buffer size (must be called before any I/O)
    char buffer[1024];
    setvbuf(fp, buffer, _IOFBF, sizeof(buffer));  // Fully buffered

    // Or use setbuf
    // setbuf(fp, buffer);  // Enable buffering
    // setbuf(fp, NULL);    // Disable buffering

    // Alternative: use buffer modes
    // setvbuf(fp, NULL, _IONBF, 0);  // Unbuffered
    // setvbuf(fp, NULL, _IOLBF, 0);  // Line buffered
    // setvbuf(fp, NULL, _IOFBF, 0);  // Fully buffered (system size)

    fprintf(fp, "Data\n");

    fclose(fp);
    return 0;
}

Flushing the Buffer

#include <stdio.h>

int main() {
    FILE *fp = fopen("log.txt", "w");

    fprintf(fp, "Important message");

    // Force write to disk immediately
    fflush(fp);

    // ... program continues, data is safe on disk ...

    fclose(fp);
    return 0;
}

Standard Streams

C automatically opens three standard streams when a program starts:

The Three Standard Streams

Stream	Pointer	Default	Purpose
Standard Input	`stdin`	Keyboard	Read user input
Standard Output	`stdout`	Screen	Normal program output
Standard Error	`stderr`	Screen	Error messages

┌─────────────────────────────────────────────────────────────────┐
│                      Standard Streams                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────┐      stdin        ┌─────────┐                    │
│  │ Keyboard │ ────────────────► │         │                    │
│  └──────────┘                   │         │                    │
│                                 │ Program │                    │
│  ┌──────────┐      stdout       │         │                    │
│  │  Screen  │ ◄──────────────── │         │                    │
│  │          │      stderr       │         │                    │
│  │          │ ◄──────────────── │         │                    │
│  └──────────┘                   └─────────┘                    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Using Standard Streams

#include <stdio.h>

int main() {
    char name[50];

    // stdin - reading input
    fprintf(stdout, "Enter your name: ");  // Same as printf
    fscanf(stdin, "%49s", name);           // Same as scanf

    // stdout - normal output
    fprintf(stdout, "Hello, %s!\n", name); // Same as printf

    // stderr - error output
    fprintf(stderr, "Warning: This is an error message\n");

    return 0;
}

Redirecting Streams

# In shell/command line:

# Redirect stdout to file
./program > output.txt

# Redirect stderr to file
./program 2> errors.txt

# Redirect both
./program > output.txt 2> errors.txt

# Redirect stdin from file
./program < input.txt

# Combine all
./program < input.txt > output.txt 2> errors.txt

Reopening Standard Streams

#include <stdio.h>

int main() {
    // Redirect stdout to a file
    FILE *fp = freopen("output.txt", "w", stdout);

    if (fp == NULL) {
        fprintf(stderr, "Failed to redirect stdout\n");
        return 1;
    }

    // Now printf writes to file
    printf("This goes to output.txt\n");

    // Restore stdout (platform-specific)
    // On Linux: freopen("/dev/tty", "w", stdout);
    // On Windows: freopen("CON", "w", stdout);

    fclose(fp);
    return 0;
}

File Operations Workflow

Complete File Handling Pattern

#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp = NULL;
    int result = 0;

    // Step 1: Open the file
    fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("Error opening file");
        return EXIT_FAILURE;
    }

    // Step 2: Perform operations
    // ... read, write, or other operations ...

    // Step 3: Check for errors during operations
    if (ferror(fp)) {
        fprintf(stderr, "Error during file operations\n");
        result = EXIT_FAILURE;
    }

    // Step 4: Close the file
    if (fclose(fp) != 0) {
        perror("Error closing file");
        result = EXIT_FAILURE;
    }

    // Step 5: Nullify pointer
    fp = NULL;

    return result;
}

Workflow Diagram

┌──────────────────────────────────────────────────────────────────┐
│                    File Operations Workflow                      │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────┐                                                │
│   │   START     │                                                │
│   └──────┬──────┘                                                │
│          │                                                       │
│          ▼                                                       │
│   ┌─────────────────┐      ┌───────────────┐                    │
│   │  fopen(file)    │─NO──►│ Handle Error  │                    │
│   │  fp != NULL?    │      │ (print, exit) │                    │
│   └───────┬─────────┘      └───────────────┘                    │
│           │YES                                                   │
│           ▼                                                      │
│   ┌─────────────────┐                                            │
│   │ Perform File    │◄──────────────────┐                       │
│   │ Operations      │                   │                       │
│   │ (read/write)    │───────────────────┤                       │
│   └───────┬─────────┘                   │                       │
│           │                             │                       │
│           ▼                             │                       │
│   ┌─────────────────┐       YES         │                       │
│   │  More ops?      │───────────────────┘                       │
│   └───────┬─────────┘                                            │
│           │NO                                                    │
│           ▼                                                      │
│   ┌─────────────────┐      ┌───────────────┐                    │
│   │   fclose(fp)    │─ERR─►│ Handle Error  │                    │
│   │   == 0?         │      │ (log warning) │                    │
│   └───────┬─────────┘      └───────┬───────┘                    │
│           │OK                      │                            │
│           ▼                        │                            │
│   ┌─────────────────┐              │                            │
│   │   fp = NULL     │◄─────────────┘                            │
│   └───────┬─────────┘                                            │
│           │                                                      │
│           ▼                                                      │
│   ┌─────────────┐                                                │
│   │    END      │                                                │
│   └─────────────┘                                                │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

Common Pitfalls

1. Not Checking fopen() Return Value

// WRONG - dangerous!
FILE *fp = fopen("file.txt", "r");
fprintf(fp, "data");  // CRASH if file doesn't exist!

// CORRECT
FILE *fp = fopen("file.txt", "r");
if (fp == NULL) {
    perror("Cannot open file");
    return 1;
}
fprintf(fp, "data");

2. Forgetting to Close Files

// WRONG - resource leak
void process_files() {
    for (int i = 0; i < 1000; i++) {
        char filename[50];
        sprintf(filename, "file%d.txt", i);
        FILE *fp = fopen(filename, "r");
        // ... process ...
        // Forgot fclose(fp)!  // Eventually runs out of file handles
    }
}

// CORRECT
void process_files() {
    for (int i = 0; i < 1000; i++) {
        char filename[50];
        sprintf(filename, "file%d.txt", i);
        FILE *fp = fopen(filename, "r");
        if (fp != NULL) {
            // ... process ...
            fclose(fp);
        }
    }
}

3. Using Wrong Mode

// WRONG - "w" destroys existing content!
FILE *fp = fopen("important_data.txt", "w");  // File is now EMPTY!

// CORRECT - use "a" to append or "r+" to modify
FILE *fp = fopen("important_data.txt", "a");  // Adds to existing
// OR
FILE *fp = fopen("important_data.txt", "r+"); // Read/write without truncating

4. Mixing Text and Binary Modes

// WRONG - writing binary data in text mode
struct Data { int x; float y; } data = {42, 3.14};
FILE *fp = fopen("data.dat", "w");  // Text mode!
fwrite(&data, sizeof(data), 1, fp);  // May corrupt on Windows

// CORRECT - use binary mode for binary data
FILE *fp = fopen("data.dat", "wb");  // Binary mode
fwrite(&data, sizeof(data), 1, fp);

5. Not Handling Paths Correctly

// Platform-specific issues
// Windows uses backslashes, Linux uses forward slashes

// PORTABLE approach - use forward slashes (works on both)
FILE *fp = fopen("data/input/file.txt", "r");

// Or use path construction
char path[256];
snprintf(path, sizeof(path), "data%cinput%cfile.txt",
         '/', '/');  // Use '/' for portability

Best Practices

1. Always Check Return Values

FILE *fp = fopen(filename, "r");
if (fp == NULL) {
    // Handle error appropriately
    perror("Failed to open file");
    return -1;
}

2. Use Meaningful Variable Names

// POOR
FILE *f;

// BETTER
FILE *inputFile;
FILE *outputFile;
FILE *configFile;

3. Close Files as Soon as Possible

// Read all data, then close
FILE *fp = fopen("data.txt", "r");
if (fp != NULL) {
    // Read all needed data
    char buffer[1000];
    fgets(buffer, sizeof(buffer), fp);

    // Close immediately after reading
    fclose(fp);
    fp = NULL;

    // Process data (file is already closed)
    process(buffer);
}

4. Use Helper Functions

// Create reusable file opening function
FILE *open_file_safe(const char *filename, const char *mode) {
    FILE *fp = fopen(filename, mode);
    if (fp == NULL) {
        fprintf(stderr, "Error: Cannot open '%s' with mode '%s': %s\n",
                filename, mode, strerror(errno));
    }
    return fp;
}

// Usage
FILE *fp = open_file_safe("data.txt", "r");
if (fp != NULL) {
    // ... use file ...
    fclose(fp);
}

5. Consider Using goto for Cleanup

int process_file(const char *filename) {
    FILE *fp = NULL;
    char *buffer = NULL;
    int result = -1;

    fp = fopen(filename, "r");
    if (fp == NULL) goto cleanup;

    buffer = malloc(1000);
    if (buffer == NULL) goto cleanup;

    // ... process ...

    result = 0;  // Success

cleanup:
    if (buffer != NULL) free(buffer);
    if (fp != NULL) fclose(fp);
    return result;
}

Summary

Key Concepts

Concept	Description
FILE *	Pointer to file structure, used for all operations
fopen()	Opens a file, returns FILE * or NULL
fclose()	Closes a file, flushes buffers, returns 0 or EOF
Modes	"r", "w", "a", "r+", "w+", "a+" (add "b" for binary)
Streams	stdin, stdout, stderr are predefined FILE pointers
Buffering	Data collected in memory before disk operations

Mode Quick Reference

Mode	Exists	Not Exists	Position	Truncate
r	Read	Error	Start	No
w	Write	Create	Start	Yes
a	Write	Create	End	No
r+	R/W	Error	Start	No
w+	R/W	Create	Start	Yes
a+	R/W	Create	End(w)	No

Essential Error Checking

// Minimal safe pattern
FILE *fp = fopen("file.txt", "r");
if (fp == NULL) {
    perror("fopen");
    return 1;
}

// ... operations ...

if (fclose(fp) != 0) {
    perror("fclose");
    return 1;
}

What's Next?

In the following sections, we'll explore:

•Reading from files (fgetc, fgets, fscanf, fread)
•Writing to files (fputc, fputs, fprintf, fwrite)
•File positioning (fseek, ftell, rewind)
•Binary file operations
•Error handling and file status

Practice Exercises Preview

•Open a file and check if it exists
•Create a new file with sample content
•Handle file opening errors gracefully
•Work with different file modes
•Redirect stdout to a file

File Handling

File Basics in C

Table of Contents

Introduction

What are Files?

Definition

File Characteristics

Why Use Files?

File Types in C

1. Text Files

2. Binary Files

Comparison

File Pointer (FILE *)

The FILE Structure

What FILE Contains (Conceptual)

Important Points

Opening Files - fopen()

Syntax

Parameters

Return Value

Basic Usage

File Paths

File Opening Modes

Text Mode Options

Binary Mode Options

Mode Behavior Visual

Choosing the Right Mode

Closing Files - fclose()

Syntax

Return Value

Why Close Files?

Basic Usage

Common Mistakes with fclose()

Checking File Operations

Error Checking Pattern

Common errno Values for File Operations

Using ferror() and feof()

File Handle and Streams

Buffering Concept

Buffer Types

Controlling Buffering

Flushing the Buffer

Standard Streams

The Three Standard Streams

Using Standard Streams

Redirecting Streams

Reopening Standard Streams

File Operations Workflow

Complete File Handling Pattern

Workflow Diagram

Common Pitfalls

1. Not Checking fopen() Return Value

2. Forgetting to Close Files

3. Using Wrong Mode

4. Mixing Text and Binary Modes

5. Not Handling Paths Correctly

Best Practices

1. Always Check Return Values

2. Use Meaningful Variable Names

3. Close Files as Soon as Possible

4. Use Helper Functions

5. Consider Using goto for Cleanup

Summary

Key Concepts

Mode Quick Reference

Essential Error Checking

What's Next?

Practice Exercises Preview