Files Streams

By the end of this lesson you'll be able to write data to a file, read it back line by line or token by token, choose the right file mode, and parse text in memory with std::stringstream — the same stream skills power files, the console, and strings in C++.

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

Think of a stream as a conveyor belt for characters. cout is a belt running out to your screen; cin is a belt running in from the keyboard. A file stream is the exact same belt — it just connects to a file on disk instead. Because every belt works the same way, the << ("push onto the belt") and >> ("take off the belt") operators you already know for the console work unchanged on files and on strings. Learn one, and you've learned all three.

1. Writing a File with ofstream

std::ofstream (output file stream) opens a file for writing . You give it a filename, then push data onto it with << — exactly like cout . The golden rule: always check is_open() first, because a wrong path or a read-only folder fails silently otherwise. Read this worked example, then run it locally and open scores.txt to see the result.

2. Reading a File with ifstream

std::ifstream (input file stream) opens a file for reading . You have two tools: std::getline(in, line) grabs a whole line at a time, while in >> value reads one whitespace-separated token and converts its type for you. Both return the stream itself , which becomes "false" at end-of-file (EOF) — so they're perfect loop conditions that stop on their own.

3. File Modes: app and binary

By default ofstream overwrites a file. Pass a mode flag as the second argument to change that. std::ios::app means append — new writes go to the end and existing content is kept (ideal for log files). std::ios::binary writes raw bytes with no text formatting, which you need for .write() / .read() on structs. std::fstream opens a file for reading and writing at once.

Heads-up: binary files are not portable across machines — endianness and struct padding differ between architectures. For data you'll share, prefer a text format (CSV, JSON) or a serialization library.

4. Parsing in Memory with stringstream

A std::stringstream is a stream backed by a std::string instead of a file. std::istringstream lets you read a string with getline and >> (perfect for splitting a CSV line into fields); std::ostringstream lets you build a string with << and pull the result out with .str() . Because it's all in memory, it runs anywhere — so the exercises below work right here in the editor.

Your turn. The program below is almost complete — fill in the blanks marked ___ using the // 👉 hints, then run it.

One more. This time you'll read numbers with >> and build a report string with ostringstream . Fill in the two blanks:

Common Errors (and the fix)

• Not checking is_open() : if the path is wrong or the folder is read-only, the open fails silently and your writes vanish. Always guard with if (!stream.is_open()) { /* handle it */ } before reading or writing.
• Mixing >> and getline : >> leaves the trailing newline in the buffer, so the next getline returns an empty line. After reading a number with >> , call in.ignore() (or std::ws ) before getline .
• Forgetting ios::binary : calling .write() / .read() in text mode lets newline translation corrupt your bytes on Windows. Open with ofstream out(name, ios::binary) for any non-text data.
• Not closing / not relying on RAII: data sits in a buffer until the stream is flushed. If you read the file before the writer's close() (or before it goes out of scope), it can look empty. Call .close() or let the stream's scope end first.
• Looping on !in.eof() : EOF is set after a failed read, so this processes the last line twice. Loop on the read itself instead: while (getline(in, line)) or while (in >> x) .

📋 Quick Reference

Task

Code

Open file to write

ofstream out("f.txt");

Open file to read

ifstream in("f.txt");

Read & write

fstream io("f.txt");

Append mode

ofstream(f, ios::app)

Binary mode

ifstream(f, ios::binary)

Check it opened

if (in.is_open())

Read a line

getline(in, line)

Read a token

in >> word

Split on a char

getline(ss, f, ',')

Build a string

oss << x; oss.str()

Close the file

stream.close();

Frequently Asked Questions

Mini-Challenge: Average a Row of Scores

No blanks this time — just a brief and an outline. You'll parse a comma-separated line entirely in memory with istringstream , so it runs right here. Build it, run it, and check your output against the example in the comments.

Pro Tips

• 💡 Prefer the read as your loop test: while (getline(in, line)) beats checking eof() — it never processes a phantom last line.
• 💡 Read a line, then parse it: getline the whole line from the file, then feed it to an istringstream to split the fields. Clean and robust.
• 💡 Let RAII help, but flush on purpose: the stream closes itself at scope end, but call .close() when another reader needs the data now .

🎉 Lesson Complete

• ✅ ofstream writes, ifstream reads, fstream does both — all use << / >>
• ✅ Always check is_open() ; loop on the read so EOF stops you cleanly
• ✅ getline grabs whole lines; >> grabs tokens and converts types
• ✅ ios::app appends, ios::binary writes raw bytes
• ✅ stringstream parses and builds text in memory — same stream skills, no file needed
• ✅ Close files (or rely on RAII) so the buffer is flushed
• ✅ Next lesson: Exception Safety — keep your resources sound when things go wrong

Practice quiz

Continue this course

• Previous: Memory Allocation Internals
• Next: Exception Safety