C++ Programming Tutorial

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

int main() {
    // vector — dynamic array (most used container)
    std::vector<int> vec{1, 2, 3, 4, 5};
    vec.push_back(6);
    vec.pop_back();
    std::cout << "vec size: " << vec.size() << "
";

    // deque — double-ended queue (fast insert at both ends)
    std::deque<int> dq{10, 20, 30};
    dq.push_front(5);
    dq.push_back(40);

    // list — doubly linked list (fast insert/remove anywhere)
    std::list<int> lst{1, 2, 3};
    lst.push_front(0);
    lst.remove(2);  // remove all elements with value 2

    // array — fixed-size (compile-time size)
    std::array<int, 4> arr{10, 20, 30, 40};
    std::cout << "arr[2]: " << arr[2] << "
";

    return 0;
}

#include <iostream>
#include <map>
#include <unordered_map>
#include <set>

int main() {
    // map — ordered key-value pairs (red-black tree, O(log n))
    std::map<std::string, int> ages;
    ages["Alice"] = 30;
    ages["Bob"] = 25;
    ages.insert({"Charlie", 35});

    for (const auto& [name, age] : ages) {  // structured bindings (C++17)
        std::cout << name << ": " << age << "
";
    }  // sorted by key: Alice, Bob, Charlie

    // Check if key exists
    if (ages.count("Alice")) {
        std::cout << "Alice found: " << ages["Alice"] << "
";
    }

    // unordered_map — hash table (O(1) average)
    std::unordered_map<std::string, double> prices;
    prices["apple"] = 1.50;
    prices["banana"] = 0.75;

    // set — unique sorted values
    std::set<int> unique_nums{5, 3, 1, 4, 1, 3};  // stores: {1, 3, 4, 5}
    for (int n : unique_nums) std::cout << n << " ";
    std::cout << "
";

    return 0;
}

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

int main() {
    std::vector<int> v{5, 2, 8, 1, 9, 3, 7, 4, 6};

    // Sort
    std::sort(v.begin(), v.end());  // ascending
    // std::sort(v.begin(), v.end(), std::greater<>());  // descending

    // Find
    auto it = std::find(v.begin(), v.end(), 7);
    if (it != v.end()) {
        std::cout << "Found 7 at index " << (it - v.begin()) << "
";
    }

    // Count
    int count = std::count_if(v.begin(), v.end(), [](int x) { return x > 5; });
    std::cout << "Numbers > 5: " << count << "
";

    // Transform (in-place: double each element)
    std::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * 2; });

    // Accumulate (sum)
    int sum = std::accumulate(v.begin(), v.end(), 0);
    std::cout << "Sum: " << sum << "
";

    // Min/Max
    auto [min_it, max_it] = std::minmax_element(v.begin(), v.end());
    std::cout << "Min: " << *min_it << ", Max: " << *max_it << "
";

    // Remove-erase idiom (remove even numbers)
    v.erase(std::remove_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; }), v.end());

    // For each
    std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
    std::cout << "
";

    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v{10, 20, 30, 40, 50};

    // Iterator-based loop (how algorithms work internally)
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << "
";

    // Reverse iteration
    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        std::cout << *it << " ";  // 50 40 30 20 10
    }
    std::cout << "
";

    // const iterators (read-only)
    for (auto it = v.cbegin(); it != v.cend(); ++it) {
        std::cout << *it << " ";
        // *it = 0;  // ERROR: const iterator
    }

    return 0;
}