File I/O

#include <fstream>

int main() {
    std::ofstream outFile("scores.txt");

    outFile << "Alex: 85" << std::endl;
    outFile << "Jordan: 92" << std::endl;

    outFile.close();
    return 0;
}

Creating an std::ofstream with a filename opens (creating it if it doesn't exist) that file for writing. << works EXACTLY like Phase 1's std::cout << — except the text goes into the file instead of the screen. .close() explicitly closes the file, ensuring everything is properly saved.

std::ofstream outFile("scores.txt", std::ios::app);  // append mode — adds to the end, doesn't erase existing content

By default, opening a file for writing ERASES any existing content first. Passing std::ios::app as a second argument switches to append mode — new writes are added to the end, preserving what was already there.

#include <fstream>

std::ifstream inFile("scores.txt");
std::string word;

while (inFile >> word) {   // reads one word at a time, exactly like cin >>
    std::cout << word << std::endl;
}

inFile.close();

inFile >> word reads one whitespace-separated word at a time — genuinely the exact same behavior as Phase 1 Module 6's std::cin >> word, including the "stops at spaces" limitation from that lesson. Using it as a while loop's condition works because the stream itself becomes "false" once there's nothing left to read.

A stream, when used as a condition, evaluates to true if the last read succeeded and false once it fails (typically, reaching the end of the file). This directly connects to Phase 2's loop patterns — genuinely the sentinel pattern from Phase 2 Module 6, except the "sentinel" here is the file simply running out of content, rather than a specific value the user types.

std::ifstream inFile("does_not_exist.txt");
std::string word;
inFile >> word;   // doesn't crash — word just stays unchanged, silently

Opening a nonexistent file for reading doesn't throw an exception (Phase 10) or crash by default — it just quietly fails, and subsequent reads simply don't do anything. This is a genuinely common source of confusing bugs for beginners: the program runs, produces no error, and just... does nothing useful.

std::ifstream inFile("scores.txt");

if (!inFile.is_open()) {
    std::cout << "Error: could not open scores.txt" << std::endl;
    return 1;
}
// safe to proceed — the file genuinely opened

.is_open() returns true if the file genuinely opened successfully. This directly connects to Phase 4 Module 9's null-checking discipline — verify success BEFORE trusting the resource is usable, exactly the same defensive habit applied to a different kind of resource.

std::ifstream inFile("scores.txt");
std::string line;

while (std::getline(inFile, line)) {
    std::cout << "Line: " << line << std::endl;
}

This is genuinely the exact same std::getline from Phase 1 Module 6, just given a file stream instead of std::cin — it reads one entire line at a time, spaces and all, stopping only at the newline character. The while (std::getline(...)) pattern works identically to Module 3's while (inFile >> word) — the function itself returns something that evaluates to false once there's nothing left to read.

Alex,25,alex@example.com
Jordan,30,jordan@example.com

Each line has three pieces of data (name, age, email), separated by commas — a genuinely common, simple real-world format. To parse it, you need to split each line at the commas.

#include <sstream>

std::string line = "Alex,25,alex@example.com";
std::stringstream ss(line);
std::string name, ageStr, email;

std::getline(ss, name, ',');      // reads up to the first comma: "Alex"
std::getline(ss, ageStr, ',');    // reads up to the next comma: "25"
std::getline(ss, email, ',');     // reads to the end: "alex@example.com"

int age = std::stoi(ageStr);   // convert the text "25" into a real int

std::stringstream treats a std::string AS IF it were a stream — letting you reuse Module 4's std::getline, but with a custom delimiter (',' instead of the default newline) to split the line at each comma. std::stoi ("string to int") converts the resulting text into a real number, exactly like Phase 10's capstone used it.

Build a Contact class (Phase 5), a function to save a vector<Contact> (Phase 7) to a CSV file, and a function to load them back — genuinely surviving between separate runs of the program, not just within one execution.

• loadContacts checks .is_open() (Module 4) and handles a missing file gracefully — the FIRST time this program ever runs, there's genuinely no file yet, and that's a normal, expected case, not an error.
• Each line is parsed with Module 6's stringstream/comma-delimiter pattern into a real Contact object.
• Run this program, close it, and run it again — the contact you added persists, genuinely proving the data survived between separate executions, not just within one run.