File Handling and Streams: iostream, fstream, Text/Binary Files and Basic Best Practices Questions

Question 1

Define file handling.

Accepted Answer

**File handling** is reading/writing data to files for **permanent storage**.

Question 2

Which header is used for file streams?

Accepted Answer

**<fstream>**.

Question 3

What is ifstream used for?

Accepted Answer

**ifstream** is used to **read** data from a file.

Question 4

What is ofstream used for?

Accepted Answer

**ofstream** is used to **write** data to a file.

Question 5

What does ios::app do?

Accepted Answer

`ios::app` opens file in **append** mode (writes at end).

Question 6

Name one correct loop to read until EOF.

Accepted Answer

Example: `while (in >> x) { ... }`.

Question 7

Explain the need of file handling.

Accepted Answer

File handling provides **permanent storage**. Data stored in variables is temporary and lost after program ends. Files allow saving records, retrieving later, and sharing data between programs. Hence file handling is essential for real applications.

Question 8

Differentiate between ifstream, ofstream and fstream.

Accepted Answer

- **ifstream**: input file stream (read)
- **ofstream**: output file stream (write)
- **fstream**: both read and write

They are provided by `<fstream>`.

Question 9

Explain file open modes ios::app and ios::trunc.

Accepted Answer

**ios::app** opens file for writing at the end (append). **ios::trunc** clears existing content when opening for writing. Using the wrong mode can cause data loss, so choose carefully.

Question 10

Explain getline() and why it is used.

Accepted Answer

`getline(stream, line)` reads a complete line including spaces. It is used when input contains spaces (names, sentences) where `>>` would stop at whitespace.

Question 11

Explain why while(!eof()) is not recommended.

Accepted Answer

`eof()` becomes true only after a failed read, so `while(!eof())` often processes the last read twice or reads invalid data. Better: `while(in >> x)` or `while(getline(in,line))`.

Question 12

Explain text file vs binary file (brief).

Accepted Answer

**Text files** store readable characters and are easy to edit, but can be larger. **Binary files** store raw bytes, are compact and faster, but not human-readable. Choose based on application needs.

Question 13

Explain file handling in C++ with basic steps and a flowchart.

Accepted Answer

### **Explain file handling in C++ (need + basic steps) with flow**

File handling is used for **permanent storage** of data. Data stored in variables is lost when program ends, but file data remains.

**Basic steps**:
1) Create a stream object (**ifstream/ofstream/fstream**)
2) **Open** the file (constructor or `open()`)
3) **Check** if file opened successfully
4) **Read/Write** data
5) **Close** the file

```text
Create stream → open → check success → read/write → close
```

Thus file handling helps store and retrieve data reliably.

Question 14

Explain file open modes in C++ with a table and examples.

Accepted Answer

### **Explain file open modes in C++ with a table**

File open modes specify how a file should be opened.

| Mode | Meaning |
|---|---|
| **ios::in** | open for reading |
| **ios::out** | open for writing |
| **ios::app** | append at end |
| **ios::trunc** | clear existing content |
| **ios::binary** | open in binary mode |

Modes can be combined using `|`.
Example: `ios::out | ios::app`.

So correct mode selection prevents data loss and controls read/write behaviour.

Question 15

Differentiate text and binary files and explain a correct EOF reading approach with table.

Accepted Answer

### **Explain text vs binary files and mention one reading loop best practice**

**Text files** store readable characters, easy to view/edit, but can be larger and slower for structured data.

**Binary files** store data in raw bytes, compact and faster, but not human-readable.

| File type | Stored as | Advantage | Disadvantage |
|---|---|---|---|
| Text | characters | readable | larger/format issues |
| Binary | bytes | fast/compact | not readable |

**Best practice for reading till EOF**:
- Use stream condition: `while (in >> x)` or `while(getline(in,line))`
- Avoid `while(!in.eof())` because it can process the last read incorrectly.

Thus choose file type and reading pattern based on application needs.

File Handling and Streams: iostream, fstream, Text/Binary Files and Basic Best Practices

8 more questions to unlock