Writing to files in C - Step-by-Step Execution

Concept Flow - Writing to files

Start

↓

Open file with fopen

↓

Check if file opened

Yes No↓

Write data

↓

Close file with fclose

↓

End

The program opens a file, checks if it opened successfully, writes data if yes, then closes the file.

Execution Sample

C

#include <stdio.h>

int main() {
  FILE *f = fopen("data.txt", "w");
  if (f == NULL) return 1;
  fprintf(f, "Hello\n");
  fclose(f);
  return 0;
}

This code opens a file named data.txt for writing, writes "Hello" with a newline, then closes the file.

Execution Table

Step	Action	Evaluation	Result
1	Call fopen("data.txt", "w")	File exists or created	Returns file pointer (f)
2	Check if f == NULL	File opened?	Yes, file opened successfully
3	Call fprintf(f, "Hello\n")	Write string to file	String "Hello\n" written
4	Call fclose(f)	Close file	File closed
5	Return 0	Program ends	Success

💡 Program ends after closing the file and returning 0

Variable Tracker

Variable	Start	After fopen	After fprintf	After fclose	Final
f	undefined	file pointer (valid)	file pointer (valid)	file pointer (valid)	file pointer (valid)

Key Moments - 2 Insights

Why do we check if fopen returns NULL?

Because fopen returns NULL if the file cannot be opened or created. Checking prevents writing to an invalid file pointer (see execution_table step 2).

What happens if we forget to call fclose?

The file may not save properly or resources stay open. fclose ensures data is written and file is closed (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what does fopen return if the file opens successfully?

A An integer 0

B A valid file pointer

C NULL

D A string with filename

💡 Hint

Check execution_table row 1 under Result

At which step does the program write data to the file?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at execution_table Action column for writing

If fopen returns NULL, what should the program do?

A Return or handle error

B Continue writing to file

C Close the file

D Ignore and proceed

💡 Hint

See execution_table step 2 and key_moments about fopen check

Concept Snapshot

Writing to files in C:
- Use fopen(filename, mode) to open/create file
- Check if fopen returns NULL (means error)
- Use fprintf or fwrite to write data
- Always fclose to save and close file
- Return 0 on success

Full Transcript

This example shows how to write to a file in C. First, fopen opens the file in write mode. We check if fopen returns NULL to ensure the file opened correctly. If yes, fprintf writes the string "Hello" with a newline to the file. Then fclose closes the file to save changes. Finally, the program returns 0 to indicate success.

Practice

1. What does the mode "w" mean when used with fopen in C?

easy

A. Open a file for writing, creating it if it doesn't exist, or overwriting if it does.

B. Open a file for reading only.

C. Open a file for appending data at the end.

D. Open a file in binary mode for reading and writing.

Solution

1. Step 1: Understand fopen modes

   The mode "w" in fopen means open for writing. If the file exists, it will be overwritten. If it doesn't exist, it will be created.

2. Step 2: Compare with other modes

   Other modes like "r" are for reading, "a" for appending, and "wb" for binary write. "w" specifically means write with overwrite or create.

3. Final Answer:

   Open a file for writing, creating it if it doesn't exist, or overwriting if it does. -> Option A

4. Quick Check:

   fopen mode "w" = write with overwrite [OK]

Hint: Remember: "w" means write and overwrite file [OK]

Common Mistakes:

• Confusing "w" with "a" (append mode)
• Thinking "w" opens file for reading
• Assuming "w" preserves existing content

2. Which of the following is the correct way to open a file named "data.txt" for writing in C?

easy

A. FILE *fp = fopen("data.txt", "w");

B. FILE *fp = fopen("data.txt", "r");

C. FILE *fp = fopen("data.txt", "a");

D. FILE *fp = open("data.txt", "w");

Solution

1. Step 1: Identify correct function and mode

   In C, to open a file for writing, use fopen with mode "w". The function is fopen, not open.

2. Step 2: Check each option

   FILE *fp = fopen("data.txt", "r"); uses mode "r" (read), not writing. FILE *fp = fopen("data.txt", "a"); uses "a" (append). FILE *fp = open("data.txt", "w"); uses open, which is not standard C file open function.

3. Final Answer:

   FILE *fp = fopen("data.txt", "w"); -> Option A

4. Quick Check:

   Use fopen with "w" to write [OK]

Hint: Use fopen with "w" to write files in C [OK]

Common Mistakes:

• Using open() instead of fopen()
• Using wrong mode like "r" or "a"
• Forgetting to use double quotes around filename

3. What will be the output in the file "output.txt" after running this code?

FILE *fp = fopen("output.txt", "w");
fprintf(fp, "Hello %s!", "World");
fclose(fp);

medium

A. World!

B. Hello %s!

C. Hello World!

D. Compilation error

Solution

1. Step 1: Understand fprintf usage

   fprintf writes formatted text to the file. The format string "Hello %s!" expects a string argument, which is "World" here.

2. Step 2: Determine file content

   The file will contain the formatted string with %s replaced by "World", so the file content is "Hello World!".

3. Final Answer:

   Hello World! -> Option C

4. Quick Check:

   fprintf formats string correctly [OK]

Hint: fprintf formats and writes text to file [OK]

Common Mistakes:

• Thinking %s prints literally
• Forgetting to pass argument for %s
• Assuming fprintf prints to console

4. Identify the error in this code snippet that writes "Test" to a file:

FILE *fp;
fp = fopen("test.txt", "w");
fprintf(fp, "Test");

medium

A. fopen mode "w" is incorrect for writing

B. File name should be a variable, not a string literal

C. fprintf syntax is wrong, needs format specifier

D. Missing fclose(fp) to close the file

Solution

1. Step 1: Check file opening and writing

   The file is opened correctly with fopen and mode "w". fprintf syntax is correct to write "Test".

2. Step 2: Check for missing file closure

   The code does not call fclose(fp), which is necessary to close the file and flush buffers properly.

3. Final Answer:

   Missing fclose(fp) to close the file -> Option D

4. Quick Check:

   Always close files with fclose [OK]

Hint: Always fclose after writing to file [OK]

Common Mistakes:

• Forgetting fclose causes data loss
• Confusing fopen modes
• Thinking fprintf needs format specifier always

5. You want to write multiple lines to a file "log.txt" in C. Which code snippet correctly writes these lines and ensures the file is properly handled?

1) FILE *fp = fopen("log.txt", "w");
fprintf(fp, "Line 1\n");
fprintf(fp, "Line 2\n");
fclose(fp);

2) FILE *fp = fopen("log.txt", "r");
fprintf(fp, "Line 1\n");
fclose(fp);

3) FILE *fp = fopen("log.txt", "w");
fprintf(fp, "Line 1\nLine 2\n");
// missing fclose

4) FILE *fp = fopen("log.txt", "a");
fprintf(fp, "Line 1\n");
fclose(fp);

hard

A. Options 1 and 4

B. Option 1 only

C. Option 3 only

D. Option 2 only

Solution

1. Step 1: Analyze each option's correctness

   Option 1 opens file with "w" (write), writes two lines separately, and closes file properly. This is correct.

2. Step 2: Check other options

   Option 2 opens with "r" (read), so writing causes error. Option 3 writes lines but misses fclose, risking data loss. Option 4 opens with "a" (append), writes only one line, but the goal is multiple lines.

3. Final Answer:

   Option 1 only -> Option B

4. Quick Check:

   "w" + multiple fprintf + fclose [OK]

Hint: Use "w" mode and always fclose [OK]

Common Mistakes:

• Using "r" mode when writing
• Forgetting fclose after writing
• Not understanding difference between "w" and "a"