STL Overview

Section: C++ STL. C++ STL overview — containers, iterators, algorithms, adapters, and why the Standard Template Library saves time.

STL overview — containers, iterators, algorithms

The Standard Template Library gives you ready-made data structures and algorithms. The diagram covers components, container categories, quick demos, common algorithms, iterators, adapters, advantages, and use cases.

• Containers: store data (vector, map, set, …).
• Iterators: walk ranges like generalized pointers.
• Algorithms: sort, find, count on [begin, end).
• Adapters: stack, queue, priority_queue.

#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <string>
#include <unordered_set>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};
    v.push_back(40);
    for (int x : v) cout << x << " ";
    cout << "\n";

    list<int> lst;
    lst.push_back(2);
    lst.push_front(1);

    set<int> s = {3, 1, 2, 2}; // {1,2,3}
    map<string, int> m{{"A", 10}, {"B", 20}};
    unordered_set<int> us = {5, 1, 5};
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> v = {4, 1, 3, 2};
    sort(v.begin(), v.end());
    reverse(v.begin(), v.end());
    cout << count(v.begin(), v.end(), 2) << "\n";
    cout << *max_element(v.begin(), v.end()) << "\n";
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};
    for (auto it = v.begin(); it != v.end(); ++it)
        cout << *it << " ";
    cout << "\n";
    return 0;
}

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

int main() {
    stack<int> st;
    st.push(1); st.push(2);
    cout << st.top() << "\n"; // 2

    queue<int> q;
    q.push(10); q.push(20);
    cout << q.front() << "\n"; // 10

    priority_queue<int> pq;
    pq.push(3); pq.push(9);
    cout << pq.top() << "\n"; // 9
    return 0;
}

• STL = containers + iterators + algorithms.
• Algorithms use [begin, end) ranges — never dereference end().
• Default sequence container: vector.
• map/set sorted; unordered_* hashed.
• Adapters: stack LIFO, queue FIFO, priority_queue heap.
• Prefer range-for for simple traversal.
• Lambdas customize sort/find_if cleanly.
• Include the right header for each container/algorithm.
• Know complexity before picking a container.
• STL is template-based — types must support needed ops.
• Focus on logic; let STL handle data structure details.
• Next: deep-dive vector, then set/map pages in this course.

1. Create a vector, sort it, and print with range-for.
2. Use find and count on a vector of ints.
3. Build a map of names to ages; print key/value pairs.
4. Fill a set from an array with duplicates; show unique sorted output.
5. Push/pop a stack and print top after each change.
6. Simulate a queue of tasks with push/front/pop.
7. Walk a vector with iterators (not range-for) and print indices mentally.
8. Write a choose-table: vector vs list vs deque for three scenarios.
9. Sort a vector descending with a lambda comparator.
10. List the header needed for vector, map, algorithm, stack.
11. Explain in comments what end() means on a diagram of 4 elements.
12. Name one real app feature you would build with unordered_map.