File I-O

📁 C++ File I/O: Your Digital Filing Cabinet

The Story Begins…

Imagine you have a magical filing cabinet in your room. You can:

• 📂 Open a drawer (open a file)
• ✍️ Write notes and put them inside (write to file)
• 📖 Read notes you saved before (read from file)
• 🔒 Close the drawer when done (close file)

That’s exactly what File I/O does in C++! “I/O” means Input/Output – getting stuff IN and putting stuff OUT of files.

🌊 What Are File Streams?

Think of a stream like a water pipe. Water flows through pipes, and data flows through streams!

graph TD
    A["Your Program"] -->|Write Stream| B["File on Disk"]
    B -->|Read Stream| A

The Three Magic Streams

Your First File Stream

#include <fstream>
using namespace std;

// Create a stream to WRITE
ofstream myWriter("diary.txt");

// Create a stream to READ
ifstream myReader("diary.txt");

// Create a stream for BOTH
fstream myNotebook("notes.txt");

Remember: Always include <fstream> – it’s your key to the filing cabinet!

🚪 File Opening Modes

When you open a drawer, you decide what you want to do. Same with files!

The Mode Menu

Combining Modes

You can mix modes like mixing colors!

// Read AND write at same time
fstream file;
file.open("game.dat",
          ios::in | ios::out);

// Write in binary, erase old
ofstream save;
save.open("save.bin",
          ios::out | ios::binary);

// Add to end without erasing
ofstream log;
log.open("log.txt", ios::app);

The | symbol means “AND this mode too!”

✏️ Reading and Writing Files

Writing to a File (Like Writing a Letter)

#include <fstream>
#include <string>
using namespace std;

int main() {
    // Open our diary
    ofstream diary("diary.txt");

    // Write some lines
    diary << "Dear Diary," << endl;
    diary << "Today I learned C++!";
    diary << endl;

    // Close when done
    diary.close();
    return 0;
}

<< sends data TO the file (think: pointing toward file)

Reading from a File (Like Reading a Letter)

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    ifstream diary("diary.txt");
    string line;

    // Read line by line
    while(getline(diary, line)) {
        cout << line << endl;
    }

    diary.close();
    return 0;
}

>> gets data FROM the file (think: pointing away from file)

Reading Word by Word

ifstream book("story.txt");
string word;

while(book >> word) {
    cout << word << " ";
}

Reading Character by Character

ifstream letter("note.txt");
char ch;

while(letter.get(ch)) {
    cout << ch;
}

🤖 Binary File I/O

Text files are for humans. Binary files are for computers!

graph TD
    A["Text File"] -->|"Hello" = 5 letters| B["5 bytes stored"]
    C["Binary File"] -->|Number 1000| D["4 bytes stored"]

Why Binary?

Writing Binary Data

#include <fstream>
using namespace std;

int main() {
    ofstream file("data.bin",
                  ios::binary);

    int score = 9500;

    // write() needs address & size
    file.write(
        (char*)&score,
        sizeof(score)
    );

    file.close();
    return 0;
}

(char*)&score = “treat this number like raw bytes” sizeof(score) = “how many bytes is this?”

Reading Binary Data

#include <fstream>
#include <iostream>
using namespace std;

int main() {
    ifstream file("data.bin",
                  ios::binary);

    int score;

    file.read(
        (char*)&score,
        sizeof(score)
    );

    cout << "Score: " << score;

    file.close();
    return 0;
}

Saving a Whole Object

struct Player {
    char name[20];
    int level;
    int coins;
};

Player hero = {"Alex", 10, 500};

// Save the hero!
ofstream save("hero.bin",
              ios::binary);
save.write(
    (char*)&hero,
    sizeof(hero)
);
save.close();

⚠️ Stream Error Handling

What if something goes wrong? Like opening a drawer that doesn’t exist?

The Error Detective Tools

Always Check If File Opened!

ifstream file("secret.txt");

if(!file.is_open()) {
    cout << "Cannot open file!";
    return 1;  // Exit with error
}

// Safe to use file now!

The Smart Way: Check Everything

ifstream file("data.txt");

if(!file) {
    cout << "Error opening file!";
    return 1;
}

int number;
while(file >> number) {
    cout << number << endl;
}

if(file.eof()) {
    cout << "Finished reading!";
} else if(file.fail()) {
    cout << "Read error occurred!";
}

file.close();

Clearing Errors

Sometimes you want to try again after an error:

file.clear();  // Reset error flags
file.seekg(0); // Go back to start

The Complete Safe Pattern

#include <fstream>
#include <iostream>
using namespace std;

int main() {
    // Try to open
    ifstream file("game.txt");

    // Check if opened
    if(!file.is_open()) {
        cerr << "File not found!";
        return 1;
    }

    string line;

    // Read with error checking
    while(getline(file, line)) {
        if(file.bad()) {
            cerr << "Read error!";
            break;
        }
        cout << line << endl;
    }

    // Always close
    file.close();

    return 0;
}

🎯 Quick Summary

graph TD
    A["File I/O"] --> B["ifstream: Read"]
    A --> C["ofstream: Write"]
    A --> D["fstream: Both"]

    B --> E["Text: getline, >>"]
    B --> F["Binary: read"]

    C --> G["Text: <<"]
    C --> H["Binary: write"]

    A --> I["Error Checks"]
    I --> J["is_open, good"]
    I --> K["eof, fail, bad"]

The Golden Rules

1. 📦 Include <fstream> – Your key to files
2. 🚪 Check is_open() – Did the door open?
3. 🔒 Always close() – Close when done!
4. ⚠️ Handle errors – Things can go wrong!
5. 🤖 Use binary – For numbers and objects

🌟 You Did It!

You just learned how to:

• ✅ Open and close files
• ✅ Read and write text
• ✅ Save data in binary
• ✅ Handle errors like a pro

Your programs can now remember things even after they stop running. That’s the magic of File I/O!

Think of it this way: Without files, your program is like a goldfish – it forgets everything! With files, it’s like an elephant – it never forgets! 🐘