How do I provide stable iteration order with std::deque for large datasets?

When working with large datasets in C++, maintaining a stable iteration order while using `std::deque` can be challenging. A stable iteration order ensures that elements are processed in the order they were inserted, even when the data structure is modified. To achieve this, it is important to be aware of the properties of `std::deque` and use proper techniques when iterating through the container.

One method is to avoid altering the order of elements while iterating. Instead of removing or adding elements directly during iteration, you can store elements to be added or removed in a temporary structure and process those after the iteration is complete. This practice can help ensure that your iteration order remains consistent.

#include <deque>
#include <iostream>

int main() {
    std::deque data = {1, 2, 3, 4, 5};

    // Temporary containers for safe modifications
    std::deque toRemove;
    std::deque toAdd;

    // Iterate and modify safely
    for (auto it = data.begin(); it != data.end(); ) {
        if (*it % 2 == 0) { // For even numbers
            toRemove.push_back(*it); // Mark for removal
            it = data.erase(it); // Remove from the original deque
        } else {
            ++it; // Move to the next element
        }
    }

    // Process removals
    for (int num : toRemove) {
        std::cout << "Removed: " << num << std::endl;
    }

    // Example: Add elements after iteration if needed
    toAdd.push_back(6);
    for (int num : toAdd) {
        data.push_back(num);
    }

    // Output the final deque
    std::cout << "Final deque: ";
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}