C++ STL Explained: Containers, Iterators & Algorithms in Practice

#include <iostream>
#include <vector>      // Container: contiguous dynamic array
#include <algorithm>   // Algorithms: sort, find, count, etc.
#include <string>

int main() {
    // CONTAINER: vector holds our employee names in dynamic memory
    std::vector<std::string> employeeNames = {
        "Priya", "Carlos", "Aisha", "Dmitri", "Mei"
    };

    // ITERATOR: begin() and end() mark the range the algorithm will operate on.
    // std::sort doesn't know or care that this is a vector —
    // it just gets two iterators and works on whatever is between them.
    std::sort(employeeNames.begin(), employeeNames.end());

    std::cout << "Sorted employees:\n";
    // Range-based for loop: syntactic sugar over iterators internally
    for (const std::string& name : employeeNames) {
        std::cout << "  " << name << "\n";
    }

    // ALGORITHM + ITERATOR: find returns an iterator pointing to the result,
    // or end() if not found. Comparing to end() is the idiomatic check.
    auto searchResult = std::find(employeeNames.begin(), employeeNames.end(), "Mei");

    if (searchResult != employeeNames.end()) {
        // Dereference the iterator with * to get the actual value
        std::cout << "\nFound employee: " << *searchResult << "\n";
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <string>

int main() {
    // --- VECTOR: best for ordered sequences you access by index ---
    std::vector<int> temperatures = {72, 68, 75, 71, 69};
    temperatures.push_back(74);  // O(1) amortized — appending is cheap
    std::cout << "Third temperature reading: " << temperatures[2] << "\n";

    // --- SET: unique elements, always sorted, O(log n) insert/lookup ---
    // Real use case: tracking unique visitor IDs in a session
    std::set<std::string> uniqueVisitors;
    uniqueVisitors.insert("user_9821");
    uniqueVisitors.insert("user_4453");
    uniqueVisitors.insert("user_9821");  // Duplicate — silently ignored by set
    std::cout << "\nUnique visitor count: " << uniqueVisitors.size() << "\n"; // Prints 2

    // --- MAP: key-value, sorted by key, O(log n) lookup ---
    // Real use case: storing a product catalog by product code
    std::map<std::string, double> productPrices;
    productPrices["SKU-001"] = 29.99;
    productPrices["SKU-002"] = 49.99;
    productPrices["SKU-003"] = 9.99;

    std::cout << "\nProduct catalog (sorted by SKU):\n";
    for (const auto& [sku, price] : productPrices) {  // Structured bindings (C++17)
        std::cout << "  " << sku << " -> $" << price << "\n";
    }

    // --- UNORDERED_MAP: O(1) average lookup, no sorted order ---
    // Real use case: caching computed results by input value
    std::unordered_map<std::string, int> wordFrequency;
    std::vector<std::string> words = {"apple", "banana", "apple", "cherry", "banana", "apple"};

    for (const std::string& word : words) {
        // operator[] inserts a 0 if key doesn't exist, then we increment
        wordFrequency[word]++;
    }

    std::cout << "\nWord frequencies:\n";
    for (const auto& [word, count] : wordFrequency) {
        std::cout << "  " << word << ": " << count << "\n";
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>    // For std::accumulate
#include <string>

struct Employee {
    std::string name;
    int yearsExperience;
    double salary;
};

int main() {
    std::vector<Employee> team = {
        {"Priya",  8, 95000.0},
        {"Carlos", 2, 62000.0},
        {"Aisha",  5, 78000.0},
        {"Dmitri", 2, 65000.0},
        {"Mei",   11, 110000.0}
    };

    // --- std::sort with a lambda comparator ---
    // Sort employees by salary descending — intent is crystal clear
    std::sort(team.begin(), team.end(),
        [](const Employee& a, const Employee& b) {
            return a.salary > b.salary;  // '>' for descending order
        });

    std::cout << "Team ranked by salary:\n";
    for (const Employee& emp : team) {
        std::cout << "  " << emp.name << ": $" << emp.salary << "\n";
    }

    // --- std::count_if: count employees with more than 4 years experience ---
    int seniorCount = std::count_if(team.begin(), team.end(),
        [](const Employee& emp) {
            return emp.yearsExperience > 4;
        });
    std::cout << "\nSenior employees (5+ years): " << seniorCount << "\n";

    // --- std::find_if: find the first employee earning over $90k ---
    auto highEarner = std::find_if(team.begin(), team.end(),
        [](const Employee& emp) {
            return emp.salary > 90000.0;
        });

    if (highEarner != team.end()) {
        std::cout << "First high earner found: " << highEarner->name << "\n";
    }

    // --- ERASE-REMOVE IDIOM: remove junior employees (< 3 years) from the vector ---
    // Step 1: std::remove_if shuffles matching elements to the back,
    //         returns an iterator to the start of the 'garbage' zone.
    // Step 2: erase() actually deallocates from that point to end().
    team.erase(
        std::remove_if(team.begin(), team.end(),
            [](const Employee& emp) {
                return emp.yearsExperience < 3;  // Remove juniors
            }),
        team.end()  // Erase from the 'new end' to the actual end
    );

    std::cout << "\nTeam after removing juniors (< 3 years):\n";
    for (const Employee& emp : team) {
        std::cout << "  " << emp.name << " (" << emp.yearsExperience << " yrs)\n";
    }

    // --- std::accumulate: total salary of remaining team ---
    double totalSalary = std::accumulate(team.begin(), team.end(), 0.0,
        [](double runningTotal, const Employee& emp) {
            return runningTotal + emp.salary;  // Fold each salary into the total
        });
    std::cout << "\nTotal payroll: $" << totalSalary << "\n";

    return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <string>

int main() {
    std::vector<std::string> logEntries = {
        "[INFO]  Server started",
        "[DEBUG] Connection opened",
        "[ERROR] Timeout on port 8080",
        "[INFO]  Retry attempt 1",
        "[ERROR] Retry failed"
    };

    // --- Pattern 1: Explicit iterator with ++ and dereference ---
    // Using 'auto' instead of std::vector<std::string>::iterator (same thing, less noise)
    std::cout << "All log entries:\n";
    for (auto it = logEntries.begin(); it != logEntries.end(); ++it) {
        std::cout << "  " << *it << "\n";  // Dereference iterator to get value
    }

    // --- Pattern 2: Iterator arithmetic (only works on random-access iterators!) ---
    // Jump directly to the third element — O(1) because vector is contiguous memory
    auto thirdEntry = logEntries.begin() + 2;
    std::cout << "\nThird entry: " << *thirdEntry << "\n";

    // Distance between iterators tells us the index
    auto errorIt = std::find_if(logEntries.begin(), logEntries.end(),
        [](const std::string& entry) { return entry.rfind("[ERROR]", 0) == 0; });

    if (errorIt != logEntries.end()) {
        // std::distance works on all iterator categories but is O(1) for random-access
        auto errorIndex = std::distance(logEntries.begin(), errorIt);
        std::cout << "First error at index: " << errorIndex << "\n";
    }

    // --- Pattern 3: Reverse iteration with rbegin() and rend() ---
    // Reading logs in reverse (newest first) without copying the vector
    std::cout << "\nLast 2 entries (reverse order):\n";
    int count = 0;
    for (auto rit = logEntries.rbegin(); rit != logEntries.rend() && count < 2; ++rit, ++count) {
        std::cout << "  " << *rit << "\n";
    }

    // --- std::list: bidirectional only — no random access, no iterator arithmetic ---
    std::list<int> taskQueue = {101, 205, 308, 412};
    auto taskIt = taskQueue.begin();
    ++taskIt;  // OK: move forward one step
    ++taskIt;  // OK: move forward again
    // taskIt + 2  <-- This would NOT compile for std::list!
    // Use std::advance(taskIt, 2) for portable forward movement on any iterator type
    std::cout << "\nThird task ID: " << *taskIt << "\n";

    return 0;
}