STL Iterators in C++ Explained — Types, Usage and Real-World Patterns

#include <iostream>
#include <vector>
#include <list>
#include <iterator>   // std::distance, std::advance
#include <algorithm>  // std::sort, std::find

int main() {
    // --- Random Access Iterator (std::vector) ---
    std::vector<int> temperatures = {28, 31, 19, 25, 22, 30, 17};

    // Iterators returned by begin() / end() are random-access for vector
    auto first = temperatures.begin();
    auto last  = temperatures.end();

    // Random-access: we can jump forward by 3 in O(1)
    auto midpoint = first + 3;
    std::cout << "Element at index 3: " << *midpoint << "\n"; // 25

    // Random-access: std::sort requires this category
    std::sort(first, last);
    std::cout << "Sorted temperatures: ";
    for (auto it = temperatures.begin(); it != temperatures.end(); ++it) {
        std::cout << *it << " ";  // dereference to read the value
    }
    std::cout << "\n";

    // --- Bidirectional Iterator (std::list) ---
    std::list<std::string> taskQueue = {"render", "compress", "upload", "notify"};

    auto taskIt = taskQueue.end();
    --taskIt;  // step BACKWARDS — valid for bidirectional, not for forward
    std::cout << "Last task: " << *taskIt << "\n"; // notify

    // std::sort(taskQueue.begin(), taskQueue.end()); // COMPILE ERROR — list
    // iterators are not random-access. Use taskQueue.sort() instead.
    taskQueue.sort();
    std::cout << "Sorted tasks: ";
    for (const auto& task : taskQueue) {
        std::cout << task << " ";
    }
    std::cout << "\n";

    // --- std::advance and std::distance work across categories ---
    std::vector<int> scores = {10, 20, 30, 40, 50};
    auto scoreIt = scores.begin();
    std::advance(scoreIt, 3);  // jumps by 3 — O(1) for vector, O(n) for list
    std::cout << "Score after advance(3): " << *scoreIt << "\n"; // 40

    auto gap = std::distance(scores.begin(), scoreIt); // O(1) for vector
    std::cout << "Distance from begin: " << gap << "\n"; // 3

    return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>  // std::remove_if

// Remove all scores below a threshold from a VECTOR safely
void removeWeakScores(std::vector<int>& scores, int threshold) {
    // WRONG approach (commented out) — erasing inside a ranged for loop
    // over a vector causes undefined behaviour because iterators are
    // invalidated after erase and the loop's internal iterator is now dangling.
    //
    // for (auto it = scores.begin(); it != scores.end(); ++it) {
    //     if (*it < threshold) scores.erase(it); // BUG: it is now invalid!
    // }

    // CORRECT approach — erase-remove idiom
    // std::remove_if doesn't actually erase; it shuffles matching elements
    // to the end and returns an iterator to the new logical end.
    auto newEnd = std::remove_if(
        scores.begin(),
        scores.end(),
        [threshold](int score) { return score < threshold; }
    );
    // Now erase the dead zone in a single call — only ONE reallocation risk
    scores.erase(newEnd, scores.end());
}

// Remove all tasks containing "legacy" from a LIST safely
void removeLegacyTasks(std::list<std::string>& tasks) {
    // For std::list, erasing a node only invalidates the iterator TO that node.
    // We capture the next iterator BEFORE we erase, so the loop stays valid.
    for (auto it = tasks.begin(); it != tasks.end(); /* no increment here */) {
        if (it->find("legacy") != std::string::npos) {
            it = tasks.erase(it); // erase returns the next valid iterator
        } else {
            ++it; // only advance if we didn't erase
        }
    }
}

int main() {
    std::vector<int> playerScores = {45, 12, 88, 7, 63, 3, 95, 21};
    std::cout << "Before cleanup: ";
    for (int s : playerScores) std::cout << s << " ";
    std::cout << "\n";

    removeWeakScores(playerScores, 20);
    std::cout << "After removing scores below 20: ";
    for (int s : playerScores) std::cout << s << " ";
    std::cout << "\n";

    std::list<std::string> pipeline = {
        "fetch_data", "legacy_transform", "validate",
        "legacy_format", "publish"
    };
    removeLegacyTasks(pipeline);
    std::cout << "Pipeline after removing legacy steps: ";
    for (const auto& step : pipeline) std::cout << step << " ";
    std::cout << "\n";

    return 0;
}

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

// Generic function — works with ANY container that provides
// bidirectional or random-access iterators.
// InputIt is deduced by the compiler at each call site.
template <typename InputIt>
void printReversed(InputIt first, InputIt last) {
    // Reverse iterators constructed from the end and begin of the range
    // rFirst points to the element BEFORE last (i.e., the last valid element)
    std::reverse_iterator<InputIt> rFirst(last);
    std::reverse_iterator<InputIt> rLast(first);

    for (auto it = rFirst; it != rLast; ++it) {
        std::cout << *it << " ";
    }
    std::cout << "\n";
}

// Demonstrates const_iterator — this function cannot modify the container
void analyseReadings(const std::vector<double>& sensorReadings) {
    // cbegin() / cend() return const_iterator even on a non-const container.
    // Using them on a const& makes it explicit: we will NOT modify data.
    double total = std::accumulate(sensorReadings.cbegin(), sensorReadings.cend(), 0.0);
    double average = total / static_cast<double>(sensorReadings.size());

    // Find the first reading that's an anomaly (more than 2x the average)
    auto anomaly = std::find_if(
        sensorReadings.cbegin(),
        sensorReadings.cend(),
        [average](double reading) { return reading > average * 2.0; }
    );

    if (anomaly != sensorReadings.cend()) {
        // std::distance between cbegin() and anomaly gives the index
        auto index = std::distance(sensorReadings.cbegin(), anomaly);
        std::cout << "Anomaly found at index " << index
                  << ": value = " << *anomaly << "\n";
    } else {
        std::cout << "No anomalies detected.\n";
    }
    std::cout << "Average reading: " << average << "\n";
}

int main() {
    std::vector<int> floorNumbers = {1, 2, 3, 4, 5, 6, 7, 8};
    std::cout << "Floors top-down: ";
    printReversed(floorNumbers.begin(), floorNumbers.end()); // uses vector iterators

    std::vector<std::string> cities = {"Tokyo", "Berlin", "Lagos", "Sydney"};
    std::cout << "Cities reversed: ";
    printReversed(cities.begin(), cities.end()); // same function, different type

    // Reverse iteration over a map (ordered by key, so reversed = descending key)
    std::map<int, std::string> errorCodes = {
        {200, "OK"}, {404, "Not Found"}, {500, "Server Error"}, {403, "Forbidden"}
    };
    std::cout << "Error codes (descending): ";
    for (auto it = errorCodes.rbegin(); it != errorCodes.rend(); ++it) {
        std::cout << it->first << ":" << it->second << "  ";
    }
    std::cout << "\n";

    // Sensor analysis using const_iterator internally
    std::vector<double> readings = {18.2, 19.1, 17.8, 20.0, 61.5, 18.9, 19.4};
    analyseReadings(readings);

    return 0;
}