C++ STL Containers

Overview

The Standard Template Library (STL) provides a collection of container classes that store and organize data efficiently.

Sequence Containers

std::vector

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // Vector declaration and initialization
    std::vector<int> vec = {10, 20, 30, 40, 50};
    
    // Add elements
    vec.push_back(60);
    vec.insert(vec.begin() + 2, 25);  // Insert at position 2
    
    // Access elements
    std::cout << "First element: " << vec.front() << std::endl;
    std::cout << "Last element: " << vec.back() << std::endl;
    std::cout << "Element at index 2: " << vec[2] << std::endl;
    
    // Size and capacity
    std::cout << "Size: " << vec.size() << std::endl;
    std::cout << "Capacity: " << vec.capacity() << std::endl;
    
    // Iterate
    std::cout << "Elements: ";
    for (int value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    // Remove elements
    vec.pop_back();  // Remove last element
    vec.erase(vec.begin());  // Remove first element
    
    return 0;
}

std::list

#include <iostream>
#include <list>

int main() {
    // List declaration
    std::list<int> lst = {10, 20, 30, 40, 50};
    
    // Add elements
    lst.push_front(5);   // Add to front
    lst.push_back(60);   // Add to back
    lst.insert(++lst.begin(), 15);  // Insert after first element
    
    // Access elements (no random access)
    std::cout << "First element: " << lst.front() << std::endl;
    std::cout << "Last element: " << lst.back() << std::endl;
    
    // Iterate
    std::cout << "Elements: ";
    for (int value : lst) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    // Remove elements
    lst.pop_front();
    lst.pop_back();
    lst.remove(30);  // Remove all occurrences of 30
    
    return 0;
}

std::deque

#include <iostream>
#include <deque>

int main() {
    // Deque declaration
    std::deque<int> dq = {10, 20, 30};
    
    // Add elements to both ends
    dq.push_front(5);
    dq.push_back(40);
    
    // Random access
    std::cout << "Element at index 2: " << dq[2] << std::endl;
    
    // Iterate
    std::cout << "Elements: ";
    for (int value : dq) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Associative Containers

std::map

#include <iostream>
#include <map>
#include <string>

int main() {
    // Map declaration
    std::map<std::string, int> ages;
    
    // Insert elements
    ages["Alice"] = 25;
    ages["Bob"] = 30;
    ages.insert({"Charlie", 35});
    
    // Access elements
    std::cout << "Alice's age: " << ages["Alice"] << std::endl;
    
    // Check if key exists
    if (ages.find("Bob") != ages.end()) {
        std::cout << "Bob is in the map" << std::endl;
    }
    
    // Iterate
    std::cout << "All ages:" << std::endl;
    for (const auto& pair : ages) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    
    // Remove element
    ages.erase("Charlie");
    
    return 0;
}

std::set

#include <iostream>
#include <set>

int main() {
    // Set declaration
    std::set<int> numbers;
    
    // Insert elements
    numbers.insert(10);
    numbers.insert(20);
    numbers.insert(30);
    numbers.insert(10);  // Duplicate, won't be inserted
    
    // Check if element exists
    if (numbers.find(20) != numbers.end()) {
        std::cout << "20 is in the set" << std::endl;
    }
    
    // Size
    std::cout << "Set size: " << numbers.size() << std::endl;
    
    // Iterate (sorted order)
    std::cout << "Elements: ";
    for (int value : numbers) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Unordered Containers (C++11)

std::unordered_map

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    // Unordered map declaration
    std::unordered_map<std::string, int> word_count;
    
    // Insert elements
    word_count["hello"] = 2;
    word_count["world"] = 3;
    word_count["cpp"] = 1;
    
    // Access elements
    std::cout << "Count of 'hello': " << word_count["hello"] << std::endl;
    
    // Iterate (no guaranteed order)
    std::cout << "Word counts:" << std::endl;
    for (const auto& pair : word_count) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    
    return 0;
}

Container Adapters

std::stack

#include <iostream>
#include <stack>

int main() {
    // Stack declaration
    std::stack<int> st;
    
    // Push elements
    st.push(10);
    st.push(20);
    st.push(30);
    
    // Access top element
    std::cout << "Top element: " << st.top() << std::endl;
    
    // Pop elements
    while (!st.empty()) {
        std::cout << "Popped: " << st.top() << std::endl;
        st.pop();
    }
    
    return 0;
}

std::queue

#include <iostream>
#include <queue>

int main() {
    // Queue declaration
    std::queue<int> q;
    
    // Enqueue elements
    q.push(10);
    q.push(20);
    q.push(30);
    
    // Access front element
    std::cout << "Front element: " << q.front() << std::endl;
    
    // Dequeue elements
    while (!q.empty()) {
        std::cout << "Dequeued: " << q.front() << std::endl;
        q.pop();
    }
    
    return 0;
}

Choosing the Right Container

#include <iostream>
#include <vector>
#include <list>
#include <deque>

int main() {
    std::cout << "Container Selection Guide:" << std::endl;
    std::cout << "std::vector - Fast random access, slow insertion/deletion in middle" << std::endl;
    std::cout << "std::list - Fast insertion/deletion anywhere, no random access" << std::endl;
    std::cout << "std::deque - Fast random access, fast insertion/deletion at ends" << std::endl;
    std::cout << "std::map - Key-value pairs, sorted by key" << std::endl;
    std::cout << "std::unordered_map - Key-value pairs, hash table (faster lookup)" << std::endl;
    std::cout << "std::set - Unique elements, sorted" << std::endl;
    std::cout << "std::unordered_set - Unique elements, hash table (faster lookup)" << std::endl;
    
    return 0;
}