Error handling in files in C - Step-by-Step Execution

Concept Flow - Error handling in files

Start

↓

Open file

↓

Check if file opened?

No→Print error message

↓

Exit or handle error

↓

Read/Write file

↓

Check for errors during operation?

Yes→Print error message

↓

Exit or handle error

↓

Close file

↓

End

This flow shows opening a file, checking for errors, performing file operations, checking again for errors, then closing the file.

Execution Sample

C

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }
    fclose(fp);
    return 0;
}

This code tries to open a file for reading, checks if it opened successfully, prints an error if not, then closes the file.

Execution Table

Step	Action	Evaluation	Result
1	Call fopen("data.txt", "r")	Returns FILE pointer or NULL	Returns NULL if file missing or no permission
2	Check if fp == NULL	fp is NULL?	Yes or No
3	If NULL, call perror	Prints error message to stderr	Error message shown
4	If NULL, return 1	Program exits with error code	Program stops
5	If not NULL, proceed	File opened successfully	Continue
6	Call fclose(fp)	Closes file	File closed
7	Return 0	Program ends successfully	Program stops

💡 Execution stops if file open fails (fp == NULL), otherwise runs to end.

Variable Tracker

Variable	Start	After fopen	After check	Final
fp	undefined	NULL or valid FILE*	NULL or valid FILE*	NULL or valid FILE*

Key Moments - 3 Insights

Why do we check if fp == NULL after fopen?

Because fopen returns NULL if it fails to open the file. Checking fp == NULL tells us if the file was opened successfully or not, as shown in execution_table step 2.

What does perror do and why is it useful?

perror prints a readable error message explaining why fopen failed. This helps understand the problem, as shown in execution_table step 3.

Why do we return 1 after perror?

Returning 1 stops the program with an error code, indicating failure. This prevents running code that assumes the file opened, as shown in execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution table, what happens if fopen returns NULL?

A The program continues to read the file

B The program closes the file

C The program prints an error and stops

D The program ignores the error

💡 Hint

See execution_table rows 1 to 4 where fopen returns NULL and perror is called.

At which step does the program close the file?

A Step 6

B Step 4

C Step 2

D Step 7

💡 Hint

Check execution_table row 6 where fclose is called.

If we remove the check for fp == NULL, what will happen?

A The program will always print an error

B The program may crash or behave unexpectedly

C The program will close the file safely

D The program will return 0 immediately

💡 Hint

Refer to key_moments about why checking fp == NULL is important.

Concept Snapshot

Error handling in files in C:
- Use fopen() to open a file.
- Check if fopen returns NULL (means error).
- Use perror() to print error details.
- Return error code to stop program if needed.
- Always fclose() to close opened files.

Full Transcript

This example shows how to handle errors when working with files in C. First, we try to open a file using fopen. If fopen fails, it returns NULL. We check this immediately. If NULL, we print an error message using perror and stop the program by returning 1. If the file opens successfully, we proceed and close the file with fclose before ending the program normally. This prevents crashes or unexpected behavior when files cannot be accessed.

Practice

1. What does fopen return if it fails to open a file in C?

easy

A. 0

B. An empty string

C. -1

D. NULL

Solution

1. Step 1: Understand fopen behavior

   The fopen function returns a pointer to a FILE object if successful.

2. Step 2: Identify failure return value

   If fopen fails (e.g., file not found), it returns NULL to indicate error.

3. Final Answer:

   NULL -> Option D

4. Quick Check:

   fopen failure returns NULL [OK]

Hint: Remember: fopen returns NULL on failure, not zero or -1 [OK]

Common Mistakes:

• Thinking fopen returns 0 on failure
• Confusing NULL with empty string
• Assuming fopen throws an error instead of returning NULL

2. Which of the following is the correct way to check if a file was opened successfully in C?

easy

A. if (file != NULL)

B. if (file == 0)

C. if (file == -1)

D. if (file == NULL)

Solution

1. Step 1: Recall fopen return value on failure

   fopen returns NULL if it fails to open a file.

2. Step 2: Write correct check for success

   To check if opened successfully, compare the file pointer using file != NULL.

3. Final Answer:

   if (file != NULL) -> Option A

4. Quick Check:

   Check file pointer against NULL for success [OK]

Hint: Check if file pointer != NULL to confirm open success [OK]

Common Mistakes:

• Using 0 or -1 instead of NULL for pointer check
• Checking if file == NULL to confirm success
• Confusing integer and pointer comparisons

3. What will be the output of this C code snippet?

#include <stdio.h>
int main() {
    FILE *fp = fopen("nonexistent.txt", "r");
    if (fp == NULL) {
        printf("File open failed\n");
    } else {
        printf("File opened\n");
        fclose(fp);
    }
    return 0;
}

medium

A. File opened

B. File open failed

C. Compilation error

D. No output

Solution

1. Step 1: fopen tries to open a non-existing file

   The file "nonexistent.txt" does not exist, so fopen returns NULL.

2. Step 2: Check the if condition and output

   Since fp == NULL is true, the program prints "File open failed".

3. Final Answer:

   File open failed -> Option B

4. Quick Check:

   fopen fails, prints failure message [OK]

Hint: If fopen returns NULL, print error message [OK]

Common Mistakes:

• Assuming file opens successfully
• Ignoring the NULL check
• Expecting compilation error due to fopen

4. Identify the error in this code snippet that opens and closes a file:

#include <stdio.h>
int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        printf("Error opening file\n");
    }
    fclose(fp);
    return 0;
}

medium

A. Calling fclose even if fopen failed

B. Incorrect mode in fopen

C. Missing check if fclose succeeded

D. No error, code is correct

Solution

1. Step 1: Analyze fopen and NULL check

   The code checks if fp == NULL and prints error if true.

2. Step 2: Check fclose usage

   Even if fp == NULL, the code calls fclose(fp), which is invalid and causes undefined behavior.

3. Final Answer:

   Calling fclose even if fopen failed -> Option A

4. Quick Check:

   Only fclose valid file pointers, not NULL [OK]

Hint: Only call fclose if fopen succeeded (fp != NULL) [OK]

Common Mistakes:

• Calling fclose on NULL pointer
• Not checking fopen return before fclose
• Assuming fclose always succeeds without check

5. You want to safely open a file for writing, write "Hello" to it, and close it. Which code snippet correctly handles errors for all steps?

hard

A. #include
int main() {
FILE *fp = fopen("file.txt", "r");
if (fp == NULL) {
perror("Open failed");
return 1;
}
fprintf(fp, "Hello");
fclose(fp);
return 0;
}

B. #include
int main() {
FILE *fp = fopen("file.txt", "w");
fprintf(fp, "Hello");
fclose(fp);
return 0;
}

C. #include
int main() {
FILE *fp = fopen("file.txt", "w");
if (fp == NULL) {
perror("Open failed");
return 1;
}
if (fprintf(fp, "Hello") < 0) {
perror("Write failed");
fclose(fp);
return 1;
}
if (fclose(fp) != 0) {
perror("Close failed");
return 1;
}
return 0;
}

D. #include
int main() {
FILE *fp = fopen("file.txt", "w");
if (fp == NULL) {
printf("Error opening file\n");
}
fprintf(fp, "Hello");
fclose(fp);
return 0;
}

Solution

1. Step 1: Check fopen return value

   The correct code checks if fopen returns NULL and handles error with perror and exit.

2. Step 2: Check fprintf return value and fclose return value

   The correct code also checks if fprintf fails (returns negative) and if fclose fails (returns non-zero), handling errors properly.

3. Final Answer:

   The code that checks fopen, fprintf, and fclose -> Option C

4. Quick Check:

   Check fopen, fprintf, fclose return values for safe file handling [OK]

Hint: Check fopen, fprintf, fclose return values to handle errors [OK]

Common Mistakes:

• Not checking fopen return before writing
• Using wrong mode for writing
• Ignoring fclose errors
• Writing without checking fprintf success