Error handling in files in C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this file error check?

Consider this C code snippet that tries to open a file and checks for errors. What will it print if the file does not exist?

C

#include <stdio.h>

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

A Error opening file: No such file or directory

B File opened successfully

C Segmentation fault

D Compilation error

💡 Hint

Check what fopen returns when the file does not exist and how perror works.

When fopen fails to open a file, it returns NULL. perror prints the string you give it, followed by a colon, a space, and the error message corresponding to errno. Since the file does not exist, it prints 'No such file or directory'.

❓ Predict Output

intermediate

What error does this code raise?

What error will this C code produce when trying to read from a file pointer that is NULL?

C

#include <stdio.h>

int main() {
    FILE *fp = NULL;
    char buffer[10];
    fgets(buffer, 10, fp);
    return 0;
}

A No error, program runs fine

B Runtime error: file not found

C Compilation error

D Segmentation fault

💡 Hint

Think about what happens if you try to use a NULL pointer with fgets.

fgets expects a valid FILE pointer. Passing NULL causes undefined behavior, usually a segmentation fault because the program tries to access memory through a NULL pointer.

🧠 Conceptual

advanced

Which option correctly checks for file open errors?

You want to open a file for writing and handle errors properly. Which code snippet correctly checks if the file was opened successfully?

A

FILE *fp = fopen("file.txt", "w");
if (fp != NULL) {
    perror("Failed to open file");
    return 1;
}

B

FILE *fp = fopen("file.txt", "w");
if (fp == NULL) {
    perror("Failed to open file");
    return 1;
}

C

FILE *fp = fopen("file.txt", "w");
if (fp == 0) {
    perror("Failed to open file");
    return 1;
}

D

FILE *fp = fopen("file.txt", "w");
if (fp = NULL) {
    perror("Failed to open file");
    return 1;
}

💡 Hint

Remember how to compare pointers to NULL in C.

Option B correctly compares the FILE pointer to NULL using '=='. Option B incorrectly checks if fp is not NULL to detect error, which is wrong. Option B compares to 0, which is allowed but less clear; however, in C NULL is defined as 0, so it compiles but is less readable. Option B uses assignment '=' instead of comparison '==', causing a bug.

❓ Predict Output

advanced

What is the output of this code with error handling?

What will this program print if the file "data.txt" exists and contains the text "Hello"?

C

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (!fp) {
        printf("Cannot open file\n");
        return 1;
    }
    int c = fgetc(fp);
    if (c == EOF) {
        printf("Empty file\n");
    } else {
        printf("First char: %c\n", c);
    }
    fclose(fp);
    return 0;
}

A First char: H

B Cannot open file

C Empty file

D First char: EOF

💡 Hint

Check what fgetc returns when reading the first character of a non-empty file.

Since the file exists and contains "Hello", fgetc reads the first character 'H'. It is not EOF, so the program prints 'First char: H'.

❓ Predict Output

expert

What is the value of 'count' after this file reading loop?

This program counts how many characters it reads from a file. What is the value of 'count' after running if the file "input.txt" contains exactly 3 characters?

C

#include <stdio.h>

int main() {
    FILE *fp = fopen("input.txt", "r");
    if (!fp) return 1;
    int count = 0;
    int ch;
    while ((ch = fgetc(fp)) != EOF) {
        count++;
    }
    fclose(fp);
    printf("%d\n", count);
    return 0;
}

A 0

B 4

C 3

D Undefined behavior

💡 Hint

Remember that fgetc returns EOF after reading all characters.

The loop increments count for each character read until EOF is reached. Since the file has 3 characters, count becomes 3.

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