examples

/**
 * STL Containers - Examples
 * Compile: g++ -std=c++17 -Wall examples.cpp -o examples
 */

#include <iostream>
#include <vector>
#include <array>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <string>
using namespace std;

// ============================================================
// SECTION 1: VECTOR
// ============================================================

void demoVector() {
    cout << "--- vector ---\n" << endl;
    
    vector<int> v = {1, 2, 3, 4, 5};
    
    // Add/remove
    v.push_back(6);
    v.pop_back();
    
    // Access
    cout << "  v[0] = " << v[0] << endl;
    cout << "  v.at(1) = " << v.at(1) << endl;
    cout << "  front = " << v.front() << ", back = " << v.back() << endl;
    
    // Size
    cout << "  size = " << v.size() << endl;
    
    // Iteration
    cout << "  elements: ";
    for (int x : v) cout << x << " ";
    cout << endl;
    
    // Reserve
    v.reserve(100);
    cout << "  capacity after reserve: " << v.capacity() << endl;
}

// ============================================================
// SECTION 2: ARRAY
// ============================================================

void demoArray() {
    cout << "\n--- array ---\n" << endl;
    
    array<int, 5> arr = {1, 2, 3, 4, 5};
    
    cout << "  arr[2] = " << arr[2] << endl;
    cout << "  size = " << arr.size() << endl;
    
    arr.fill(0);
    cout << "  after fill(0): ";
    for (int x : arr) cout << x << " ";
    cout << endl;
}

// ============================================================
// SECTION 3: DEQUE
// ============================================================

void demoDeque() {
    cout << "\n--- deque ---\n" << endl;
    
    deque<int> dq = {2, 3, 4};
    
    dq.push_front(1);
    dq.push_back(5);
    
    cout << "  elements: ";
    for (int x : dq) cout << x << " ";
    cout << endl;
    
    dq.pop_front();
    dq.pop_back();
    
    cout << "  after pops: ";
    for (int x : dq) cout << x << " ";
    cout << endl;
}

// ============================================================
// SECTION 4: LIST
// ============================================================

void demoList() {
    cout << "\n--- list ---\n" << endl;
    
    list<int> lst = {3, 1, 4, 1, 5, 9};
    
    lst.push_front(0);
    lst.push_back(2);
    
    cout << "  before sort: ";
    for (int x : lst) cout << x << " ";
    cout << endl;
    
    lst.sort();
    cout << "  after sort: ";
    for (int x : lst) cout << x << " ";
    cout << endl;
    
    lst.unique();
    cout << "  after unique: ";
    for (int x : lst) cout << x << " ";
    cout << endl;
}

// ============================================================
// SECTION 5: SET
// ============================================================

void demoSet() {
    cout << "\n--- set ---\n" << endl;
    
    set<int> s = {3, 1, 4, 1, 5, 9, 2, 6};
    
    cout << "  elements (sorted, unique): ";
    for (int x : s) cout << x << " ";
    cout << endl;
    
    s.insert(7);
    s.erase(1);
    
    cout << "  count(5) = " << s.count(5) << endl;
    cout << "  count(10) = " << s.count(10) << endl;
    
    auto it = s.find(4);
    if (it != s.end()) cout << "  found 4" << endl;
}

// ============================================================
// SECTION 6: MAP
// ============================================================

void demoMap() {
    cout << "\n--- map ---\n" << endl;
    
    map<string, int> ages;
    ages["Alice"] = 25;
    ages["Bob"] = 30;
    ages.insert({"Charlie", 35});
    
    cout << "  Alice's age: " << ages["Alice"] << endl;
    
    // Structured bindings
    cout << "  All entries:" << endl;
    for (const auto& [name, age] : ages) {
        cout << "    " << name << ": " << age << endl;
    }
    
    // Check existence
    if (ages.find("David") == ages.end()) {
        cout << "  David not found" << endl;
    }
}

// ============================================================
// SECTION 7: UNORDERED CONTAINERS
// ============================================================

void demoUnordered() {
    cout << "\n--- unordered containers ---\n" << endl;
    
    unordered_set<int> us = {5, 2, 8, 1, 9};
    cout << "  unordered_set: ";
    for (int x : us) cout << x << " ";
    cout << endl;
    
    unordered_map<string, int> um;
    um["one"] = 1;
    um["two"] = 2;
    um["three"] = 3;
    
    cout << "  um[\"two\"] = " << um["two"] << endl;
    cout << "  bucket_count = " << um.bucket_count() << endl;
}

// ============================================================
// SECTION 8: STACK
// ============================================================

void demoStack() {
    cout << "\n--- stack ---\n" << endl;
    
    stack<int> stk;
    stk.push(1);
    stk.push(2);
    stk.push(3);
    
    cout << "  popping: ";
    while (!stk.empty()) {
        cout << stk.top() << " ";
        stk.pop();
    }
    cout << endl;
}

// ============================================================
// SECTION 9: QUEUE
// ============================================================

void demoQueue() {
    cout << "\n--- queue ---\n" << endl;
    
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    
    cout << "  processing: ";
    while (!q.empty()) {
        cout << q.front() << " ";
        q.pop();
    }
    cout << endl;
}

// ============================================================
// SECTION 10: PRIORITY QUEUE
// ============================================================

void demoPriorityQueue() {
    cout << "\n--- priority_queue ---\n" << endl;
    
    // Max heap (default)
    priority_queue<int> maxPQ;
    maxPQ.push(3);
    maxPQ.push(1);
    maxPQ.push(4);
    maxPQ.push(1);
    maxPQ.push(5);
    
    cout << "  max heap: ";
    while (!maxPQ.empty()) {
        cout << maxPQ.top() << " ";
        maxPQ.pop();
    }
    cout << endl;
    
    // Min heap
    priority_queue<int, vector<int>, greater<int>> minPQ;
    minPQ.push(3);
    minPQ.push(1);
    minPQ.push(4);
    
    cout << "  min heap: ";
    while (!minPQ.empty()) {
        cout << minPQ.top() << " ";
        minPQ.pop();
    }
    cout << endl;
}

// ============================================================
// MAIN
// ============================================================

int main() {
    cout << "╔══════════════════════════════════════╗" << endl;
    cout << "║     STL CONTAINERS - EXAMPLES        ║" << endl;
    cout << "╚══════════════════════════════════════╝" << endl;
    
    demoVector();
    demoArray();
    demoDeque();
    demoList();
    demoSet();
    demoMap();
    demoUnordered();
    demoStack();
    demoQueue();
    demoPriorityQueue();
    
    cout << "\n=== Complete ===" << endl;
    return 0;
}