STL Overview

STL Components

• Containers: Data structures that store objects
• Iterators: Objects that point to elements in containers
• Algorithms: Functions that operate on containers

1. Containers

Sequence Containers

Store elements in a linear sequence:

• vector: Dynamic array
• list: Doubly linked list
• deque: Double-ended queue
• array: Fixed-size array (C++11)
• forward_list: Singly linked list (C++11)

Associative Containers

Store elements in sorted order:

• set: Unique elements, sorted
• map: Key-value pairs, sorted by key
• multiset: Allows duplicate elements
• multimap: Allows duplicate keys

Unordered Containers (C++11)

Hash-based containers:

• unordered_set: Unique elements, hashed
• unordered_map: Key-value pairs, hashed
• unordered_multiset: Allows duplicates
• unordered_multimap: Allows duplicate keys

2. Vector

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

int main() {
    // Declaration
    vector<int> vec;
    
    // Adding elements
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    
    // Accessing elements
    cout << vec[0] << endl;        // 10
    cout << vec.at(1) << endl;     // 20
    cout << vec.front() << endl;   // 10
    cout << vec.back() << endl;    // 30
    
    // Size
    cout << vec.size() << endl;
    cout << vec.empty() << endl;
    
    // Iterating
    for (int i = 0; i < vec.size(); i++) {
        cout << vec[i] << " ";
    }
    cout << endl;
    
    // Using iterators
    for (auto it = vec.begin(); it != vec.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    // Range-based for loop
    for (int element : vec) {
        cout << element << " ";
    }
    cout << endl;
    
    return 0;
}

3. List

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

int main() {
    list<int> myList;
    
    // Adding elements
    myList.push_back(10);
    myList.push_front(5);
    myList.push_back(20);
    
    // Iterating
    for (auto it = myList.begin(); it != myList.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    // Removing elements
    myList.pop_front();
    myList.pop_back();
    
    return 0;
}

4. Map

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

int main() {
    map<string, int> studentMarks;
    
    // Inserting elements
    studentMarks["Alice"] = 90;
    studentMarks["Bob"] = 85;
    studentMarks["Charlie"] = 95;
    
    // Accessing elements
    cout << studentMarks["Alice"] << endl;
    
    // Checking if key exists
    if (studentMarks.find("Bob") != studentMarks.end()) {
        cout << "Found!" << endl;
    }
    
    // Iterating
    for (auto it = studentMarks.begin(); it != studentMarks.end(); it++) {
        cout << it->first << ": " << it->second << endl;
    }
    
    // Using range-based for loop
    for (auto& pair : studentMarks) {
        cout << pair.first << ": " << pair.second << endl;
    }
    
    return 0;
}

5. Set

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

int main() {
    set<int> mySet;
    
    // Inserting elements
    mySet.insert(30);
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(10);  // Duplicate, ignored
    
    // Iterating (automatically sorted)
    for (int element : mySet) {
        cout << element << " ";  // 10 20 30
    }
    cout << endl;
    
    // Finding elements
    if (mySet.find(20) != mySet.end()) {
        cout << "Found!" << endl;
    }
    
    // Removing elements
    mySet.erase(20);
    
    return 0;
}

6. Iterators

Iterators provide a way to access elements in containers:

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

int main() {
    vector<int> vec = {10, 20, 30, 40, 50};
    
    // Iterator types
    vector<int>::iterator it;
    
    // begin() and end()
    for (it = vec.begin(); it != vec.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    // Reverse iterators
    for (auto it = vec.rbegin(); it != vec.rend(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    // Const iterators
    vector<int>::const_iterator cit;
    for (cit = vec.cbegin(); cit != vec.cend(); cit++) {
        cout << *cit << " ";
    }
    cout << endl;
    
    return 0;
}

7. Algorithms

STL provides many algorithms in <algorithm> header:

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

int main() {
    vector<int> vec = {5, 2, 8, 1, 9, 3};
    
    // Sorting
    sort(vec.begin(), vec.end());
    
    // Reversing
    reverse(vec.begin(), vec.end());
    
    // Finding
    auto it = find(vec.begin(), vec.end(), 5);
    if (it != vec.end()) {
        cout << "Found at position: " << distance(vec.begin(), it) << endl;
    }
    
    // Counting
    int count = count(vec.begin(), vec.end(), 3);
    cout << "Count of 3: " << count << endl;
    
    // Maximum and minimum
    auto maxIt = max_element(vec.begin(), vec.end());
    auto minIt = min_element(vec.begin(), vec.end());
    cout << "Max: " << *maxIt << ", Min: " << *minIt << endl;
    
    // Accumulate (requires &lt;numeric&gt;)
    // int sum = accumulate(vec.begin(), vec.end(), 0);
    
    return 0;
}

8. Common STL Algorithms