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

Need for file handling

Programs often need to store data permanently. If we store data only in variables, it is lost when the program ends.

File handling helps to:

• store records (students, employees, bills)
• read data later
• share data between programs

So files provide permanent storage.

Streams concept: input/output stream

A stream is a flow of data (sequence of bytes/characters) between a program and an input/output device.

• Input stream: data flows into program
• Output stream: data flows out of program

C++ uses stream-based I/O for both console and files.

Standard streams: cin, cout, cerr

• cin: standard input stream
• cout: standard output stream
• cerr: standard error stream (useful for error messages)

All of these belong to the iostream library.

File streams and classes

C++ file handling uses <fstream> classes:

• ifstream: input file stream (read from file)
• ofstream: output file stream (write to file)
• fstream: both read and write

These classes provide functions like open(), close(), and stream operators << and >>.

Opening and closing files

Two ways to open:

1. Constructor method:

• ofstream out("data.txt");

2. open() method:

• ofstream out; out.open("data.txt");

Always close after use:

• out.close();

Closing ensures data is properly written and resources are released.

File open modes (important table)

Common open modes:

• ios::in (read)
• ios::out (write)
• ios::app (append)
• ios::trunc (truncate/overwrite)
• ios::binary (binary mode)

You can combine modes using |. Example: ios::out | ios::app.

Writing to a text file (basic pattern)

Pattern:

• create output stream
• open file
• write data
• close file

Concept example:

• ofstream out("a.txt");
• out << "Hello";

Reading from a text file (basic pattern)

Pattern:

• create input stream
• open file
• read data
• close file

Concept:

• ifstream in("a.txt");
• in >> word; (reads space-separated)

For full line reading, we use getline().

EOF and common reading loops

EOF means end-of-file.

Common patterns:

• while (in >> x) { ... } (good for formatted input)
• while (getline(in, line)) { ... } (good for line-by-line)

Avoid wrong pattern:

• while(!in.eof()) (often causes last line issues)

Text files vs binary files

• Text file: stored as readable characters (human-readable)
• Binary file: stored in raw bytes (more compact, faster)

Text files are easy to view/edit, but binary is efficient for structured records.

Binary read/write idea (overview)

Binary read/write is done in ios::binary mode.

Conceptually:

• write bytes of an object/record
• read bytes back

In Sem 1, focus on idea and mode usage; detailed read()/write() can be studied later.

Error handling: checking open() success

Always verify file open succeeded:

• check stream state (e.g., if(!in) or if(in.fail()))

If file fails to open:

• show error message
• avoid using the stream

Best practices (Sem 1 friendly)

• always close files
• use correct open mode (app vs trunc)
• check open success before reading/writing
• prefer getline() for full lines
• keep file formats consistent (fields separated clearly)

Common mistakes

• forgetting to close the file
• using wrong mode (accidentally truncating file)
• using while(!eof()) loop
• reading using >> when spaces exist in data (should use getline)

Mini tables/flowcharts for exam answers

File handling flow

Create stream → Open file → Check success → Read/Write → Close file

ifstream vs ofstream vs fstream

Quick Recap (1-minute revision)

• Files provide permanent storage.
• Streams are data flows; <fstream> provides file streams.
• Use ifstream/ofstream/fstream.
• Open modes: in, out, app, trunc, binary.
• Read loops: while(in>>x) or while(getline(...)). Avoid while(!eof()).
• Always check open success and close files.