The STL

#include <vector>

int scores[5] = {85, 92, 78, 95, 88};  // fixed size, forever

std::vector<int> scoresVec = {85, 92, 78, 95, 88};  // can grow!
scoresVec.push_back(100);  // adds a 6th element, automatically resizing

std::vector<int> reads as "a vector holding int values" — the type inside <> is what the vector stores. Accessing elements works EXACTLY like arrays (scoresVec[0], still zero-indexed, Phase 3 Module 1), but the size can genuinely change while your program runs.

std::vector<int> scores = {85, 92, 78};

// Phase 2's classic way still works fine:
for (int i = 0; i < scores.size(); i++) {
    std::cout << scores[i] << " ";
}

// The modern, range-based way — reads directly as "for each score in scores"
for (int score : scores) {
    std::cout << score << " ";
}

The range-based for loop reads naturally, avoids off-by-one errors entirely (Phase 2 Module 6), and is now the preferred style in modern C++ whenever you don't specifically need the index itself.

for (int& score : scores) {   // note the &
    score += 5;   // actually modifies the original vector's elements
}

Just like Phase 3 Module 7's pass-by-reference, adding & in the range-based loop lets you modify the ACTUAL elements, not just a local copy — without &, changes to score inside the loop wouldn't affect the real vector at all.

#include <map>

std::map<std::string, int> ages;
ages["Alex"] = 25;
ages["Jordan"] = 30;

std::cout << ages["Alex"];   // prints 25 — looked up by name, not position

std::map<std::string, int> reads as "a map from string keys to int values." Instead of vector[0] meaning "the first element," ages["Alex"] means "the value stored under the key 'Alex'" — genuinely different lookup logic, suited to genuinely different problems.

#include <set>

std::set<int> uniqueNumbers;
uniqueNumbers.insert(5);
uniqueNumbers.insert(3);
uniqueNumbers.insert(5);   // silently ignored — 5 is already in the set

// uniqueNumbers now contains exactly: 3, 5 (and always in sorted order)

Attempting to insert a value that's already present is a harmless no-op — the set just stays the same. This makes std::set a genuinely convenient tool whenever you need to guarantee "no duplicates" without writing that checking logic yourself.

A std::set maintains its elements in sorted order at all times, automatically — you never insert values "out of order" from the set's perspective, since it always reorganizes itself internally. This differs genuinely from std::vector, which preserves whatever order you actually insert things in.

std::vector<int> scores = {85, 92, 78};

for (std::vector<int>::iterator it = scores.begin(); it != scores.end(); it++) {
    std::cout << *it << " ";   // dereference it, just like a pointer!
}

An iterator is genuinely similar to Phase 4's pointers — *it dereferences it to get the current value, and it++ moves it forward, exactly like Phase 4 Module 4's pointer arithmetic. .begin() gives an iterator to the first element; .end() gives one representing "just past the last element" — the loop runs until it reaches that end marker.

Many STL algorithms (Module 7) and container operations — like erasing a specific element from the middle of a vector, or specifying WHERE in a container to insert something — take iterators as arguments, not raw index numbers. Understanding iterators as "a generalized, safer pointer for walking through any container" is what makes those functions' syntax make sense.

std::vector<int> scores = {85, 92, 78};
scores.erase(scores.begin() + 1);   // removes the element at position 1 (92)

#include <algorithm>

std::vector<int> scores = {85, 92, 78, 95};
std::sort(scores.begin(), scores.end());
// scores is now: 78, 85, 92, 95

std::sort takes a range — Module 5's iterators, marking the start and end — and sorts everything in between, in place. This single line replaces having to hand-write and debug a sorting algorithm yourself.

auto result = std::find(scores.begin(), scores.end(), 92);
if (result != scores.end()) {
    std::cout << "Found 92!";
} else {
    std::cout << "Not found.";
}

std::find returns an iterator pointing to the first matching element — or .end() if nothing matched, exactly the same "check against end()" pattern from Module 5. auto here just lets the compiler figure out the exact iterator type automatically, saving you from writing it out by hand.

auto square = [](int x) {
    return x * x;
};

std::cout << square(5);   // prints 25

A lambda is a small function written inline, without needing a separate name or declaration the way Phase 3's functions did. [] starts it, (int x) is the parameter list — genuinely identical in spirit to a regular function's parameters.

std::vector<int> scores = {85, 92, 78};

// sort in DESCENDING order, using a lambda to define "what comes first"
std::sort(scores.begin(), scores.end(), [](int a, int b) {
    return a > b;   // "a should come before b if a is bigger"
});
// scores is now: 92, 85, 78

Module 6's std::sort normally sorts smallest-to-largest by default. Passing a lambda as a third argument lets you define your OWN comparison rule — here, "descending" — without needing to write and name an entire separate function just for this one sort call.

#include <utility>

std::pair<std::string, int> person = {"Alex", 25};
std::cout << person.first;    // "Alex"
std::cout << person.second;   // 25

std::pair holds exactly two values, accessed via .first and .second — useful for functions that need to return two related pieces of information at once, without needing to design an entire custom class just for that.

std::map<std::string, int> ages = {{"Alex", 25}, {"Jordan", 30}};

for (const auto& entry : ages) {
    std::cout << entry.first << ": " << entry.second << std::endl;
    // entry.first is the key, entry.second is the value
}

Looping through a std::map gives you a sequence of pairs — entry.first is the key, entry.second is the value. Recognizing this connects Module 4's map directly back to this lesson's std::pair, rather than treating it as unrelated new syntax.

Build a small inventory tracker: a map from item name to quantity, functions to add/remove stock with validation, and a report that lists all items sorted by quantity, highest first.

• inventory[item] += qty in addStock takes advantage of Module 4's exact map-access behavior — it creates the entry (defaulting to 0) if new, or adds to the existing value.
• removeStock validates BEFORE modifying anything (Phase 5 Module 6's encapsulation principle, applied here without a formal class), and returns a bool so the caller knows if it actually worked.
• printReport copies the map's pairs into a vector specifically because std::map is always sorted BY KEY automatically — to sort by VALUE instead, you need a vector plus Module 7's std::sort with a custom lambda.