C & C++ Advanced Course

#include <iostream>
#include <utility>
#include <vector>
#include <string>

int main() {
    std::string a = "hello";
    std::string b = std::move(a);

    std::cout << "b = " << b << "\n";
    std::cout << "a = '" << a << "'\n";

    std::vector<int> v1 = {1, 2, 3};
    std::vector<int> v2 = std::move(v1);
    std::cout << "v2 size = " << v2.size() << ", v1 size = " << v1.size() << "\n";
    return 0;
}

#include <iostream>
#include <utility>

void sink(int &x) { std::cout << "lvalue\n"; }
void sink(int &&x) { std::cout << "rvalue\n"; }

template <typename T>
void wrapper(T &&arg) {
    sink(std::forward<T>(arg));
}

int main() {
    int x = 5;
    wrapper(x);
    wrapper(10);
    return 0;
}

#include <iostream>
#include <utility>

class Buffer {
private:
    int *data;
    size_t size;

public:
    explicit Buffer(size_t n) : data(new int[n]), size(n) {}

    ~Buffer() { delete[] data; }

    Buffer(const Buffer &other) : data(new int[other.size]), size(other.size) {
        for (size_t i = 0; i < size; i++) data[i] = other.data[i];
    }

    Buffer &operator=(const Buffer &other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            for (size_t i = 0; i < size; i++) data[i] = other.data[i];
        }
        return *this;
    }

    Buffer(Buffer &&other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    Buffer &operator=(Buffer &&other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    size_t get_size() const { return size; }
};

int main() {
    Buffer a(10);
    Buffer b = a;
    Buffer c = std::move(a);
    std::cout << "a=" << a.get_size() << " b=" << b.get_size() << " c=" << c.get_size() << "\n";
    return 0;
}

#include <iostream>
#include <memory>

struct Widget {
    int id;
    explicit Widget(int i) : id(i) {}
    ~Widget() { std::cout << "Widget " << id << " destroyed\n"; }
};

int main() {
    auto sp1 = std::make_shared<Widget>(1);
    std::weak_ptr<Widget> wp = sp1;

    {
        auto sp2 = sp1;
        std::cout << "use_count = " << sp1.use_count() << "\n";
    }

    std::cout << "after scope use_count = " << sp1.use_count() << "\n";

    if (auto locked = wp.lock())
        std::cout << "weak_ptr locked, id = " << locked->id << "\n";

    sp1.reset();

    if (wp.expired())
        std::cout << "weak_ptr expired after reset\n";
    return 0;
}

#include <iostream>
#include <vector>

template <typename T>
class Stack {
private:
    std::vector<T> items;
public:
    void push(const T &item) { items.push_back(item); }
    T pop() {
        T back = items.back();
        items.pop_back();
        return back;
    }
    bool empty() const { return items.empty(); }
};

int main() {
    Stack<int> s1;
    s1.push(10);
    s1.push(20);
    std::cout << s1.pop() << " ";
    std::cout << s1.pop() << "\n";

    Stack<std::string> s2;
    s2.push("hello");
    std::cout << s2.pop() << "\n";
    return 0;
}

#include <iostream>

void print() {
    std::cout << "\n";
}

template <typename First, typename... Rest>
void print(First first, Rest... rest) {
    std::cout << first << " ";
    print(rest...);
}

int main() {
    print(1, 2.5, 'c', "hello");
    print("only", 42);
    return 0;
}

#include <iostream>
#include <type_traits>

template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
double_value(T value) {
    return value * 2;
}

template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
double_value(T value) {
    return value * 2.0;
}

int main() {
    std::cout << double_value(5) << "\n";
    std::cout << double_value(2.5) << "\n";
    return 0;
}

#include <iostream>
#include <functional>
#include <vector>

int main() {
    int base = 10;

    auto add = [base](int x) { return base + x; };
    auto add_ref = [&base](int x) { return base + x; };

    base = 100;

    std::function<int(int)> fn = add;

    std::vector<std::function<int(int)>> funcs = {
        add,
        add_ref,
        [](int x) { return x * x; }
    };

    std::cout << "add(5) = " << add(5) << "\n";
    std::cout << "add_ref(5) = " << add_ref(5) << "\n";
    std::cout << "fn(5) = " << fn(5) << "\n";

    for (auto &f : funcs)
        std::cout << f(5) << " ";
    std::cout << "\n";
    return 0;
}

#include <iostream>
#include <tuple>
#include <string>

int add_three(int a, int b, int c) {
    return a + b + c;
}

int main() {
    auto t = std::make_tuple(1, 2, 3, std::string("hello"));

    std::cout << "size = " << std::tuple_size<decltype(t)>::value << "\n";
    std::cout << "get<0> = " << std::get<0>(t) << "\n";
    std::cout << "get<3> = " << std::get<3>(t) << "\n";

    auto args = std::make_tuple(10, 20, 30);
    int sum = std::apply(add_three, args);
    std::cout << "sum = " << sum << "\n";
    return 0;
}

#include <iostream>

template <typename... Args>
auto sum_all(Args... args) {
    return (args + ...);
}

template <typename... Args>
void print_all(Args... args) {
    ((std::cout << args << " "), ...);
    std::cout << "\n";
}

int main() {
    std::cout << "sum = " << sum_all(1, 2, 3, 4, 5) << "\n";
    print_all("hello", 42, 3.14, 'X');
    return 0;
}

#include <iostream>
#include <thread>
#include <future>
#include <chrono>

int slow_square(int x) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    return x * x;
}

int main() {
    auto fut1 = std::async(std::launch::async, slow_square, 5);
    auto fut2 = std::async(std::launch::async, slow_square, 7);

    std::cout << "Tasks launched\n";
    std::cout << "5^2 = " << fut1.get() << "\n";
    std::cout << "7^2 = " << fut2.get() << "\n";
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::queue<int> q;
std::mutex mtx;
std::condition_variable cv;

void producer() {
    for (int i = 1; i <= 5; i++) {
        {
            std::lock_guard lock(mtx);
            q.push(i);
            std::cout << "Produced " << i << "\n";
        }
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
}

void consumer() {
    for (int i = 1; i <= 5; i++) {
        std::unique_lock lock(mtx);
        cv.wait(lock, [] { return !q.empty(); });
        int value = q.front();
        q.pop();
        std::cout << "Consumed " << value << "\n";
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

std::atomic<int> counter{0};

void add_1000() {
    for (int i = 0; i < 1000; i++)
        counter.fetch_add(1, std::memory_order_relaxed);
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++)
        threads.emplace_back(add_1000);

    for (auto &t : threads)
        t.join();

    std::cout << "counter = " << counter.load() << "\n";
    return 0;
}

#include <iostream>
#include <atomic>
#include <thread>

struct Node {
    int value;
    Node *next;
};

std::atomic<Node *> head{nullptr};

void push(int value) {
    Node *n = new Node{value, nullptr};
    n->next = head.load(std::memory_order_relaxed);
    while (!head.compare_exchange_weak(n->next, n,
            std::memory_order_release, std::memory_order_relaxed)) {}
}

int main() {
    std::thread t1([] { for (int i = 0; i < 100; i++) push(i); });
    std::thread t2([] { for (int i = 100; i < 200; i++) push(i); });
    t1.join();
    t2.join();

    int count = 0;
    for (Node *n = head.load(); n; n = n->next) count++;
    std::cout << "Pushed " << count << " nodes\n";
    return 0;
}

#include <iostream>
#include <memory>
#include <vector>

class Drawable {
public:
    virtual void draw() const = 0;
    virtual ~Drawable() = default;
};

template <typename T>
class DrawableModel : public Drawable {
    T obj;
public:
    explicit DrawableModel(T o) : obj(std::move(o)) {}
    void draw() const override { obj.draw(); }
};

struct Circle {
    void draw() const { std::cout << "Drawing circle\n"; }
};

struct Square {
    void draw() const { std::cout << "Drawing square\n"; }
};

int main() {
    std::vector<std::unique_ptr<Drawable>> shapes;
    shapes.push_back(std::make_unique<DrawableModel<Circle>>(Circle{}));
    shapes.push_back(std::make_unique<DrawableModel<Square>>(Square{}));

    for (const auto &s : shapes)
        s->draw();
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

void risky() {
    Resource r;
    throw std::runtime_error("something went wrong");
}

int main() {
    try {
        risky();
    } catch (const std::exception &e) {
        std::cout << "Caught: " << e.what() << "\n";
    }
    return 0;
}

#include <iostream>
#include <iterator>

class Range {
private:
    int start;
    int end;

    class Iterator {
    private:
        int value;
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = int;
        using difference_type = std::ptrdiff_t;
        using pointer = int *;
        using reference = int &;

        explicit Iterator(int v) : value(v) {}
        int operator*() const { return value; }
        Iterator &operator++() { ++value; return *this; }
        bool operator!=(const Iterator &other) const { return value != other.value; }
    };

public:
    Range(int s, int e) : start(s), end(e) {}
    Iterator begin() const { return Iterator(start); }
    Iterator end() const { return Iterator(end); }
};

int main() {
    Range r(1, 6);
    for (int x : r)
        std::cout << x << " ";
    std::cout << "\n";
    return 0;
}

#include <iostream>
#include <variant>
#include <optional>
#include <string>

std::optional<int> find_even(int *arr, int len) {
    for (int i = 0; i < len; i++)
        if (arr[i] % 2 == 0) return arr[i];
    return std::nullopt;
}

int main() {
    std::variant<int, std::string, double> v;
    v = 42;
    std::cout << "variant int: " << std::get<int>(v) << "\n";
    v = "hello";
    std::cout << "variant str: " << std::get<std::string>(v) << "\n";

    int odds[] = {1, 3, 5, 7};
    int mixed[] = {1, 2, 3, 4};

    auto r1 = find_even(odds, 4);
    auto r2 = find_even(mixed, 4);

    if (r1) std::cout << "r1 = " << *r1 << "\n";
    else std::cout << "r1 = none\n";

    std::cout << "r2 = " << r2.value_or(-1) << "\n";
    return 0;
}

#include <iostream>
#include <concepts>

template <typename T>
requires std::integral<T>
T gcd(T a, T b) {
    while (b != 0) {
        T t = b;
        b = a % b;
        a = t;
    }
    return a;
}

template <typename T>
concept Printable = requires(T t) {
    { t.print() } -> std::same_as<void>;
};

struct Foo {
    void print() { std::cout << "Foo\n"; }
};

int main() {
    std::cout << "gcd(48, 18) = " << gcd(48, 18) << "\n";

    if constexpr (Printable<Foo>)
        Foo{}.print();
    return 0;
}

#include <iostream>
#include <coroutine>
#include <optional>

struct Generator {
    struct promise_type {
        int current;
        Generator get_return_object() { return Generator{this}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(int v) { current = v; return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    promise_type *promise;
    bool move_next() { return promise != nullptr; }
    int value() const { return promise->current; }
};

Generator count_to(int n) {
    for (int i = 1; i <= n; i++)
        co_yield i;
}

int main() {
    auto gen = count_to(5);
    std::cout << "Generated values: ";
    for (int i = 1; i <= 5; i++)
        std::cout << gen.value() << " ";
    std::cout << "\n";
    return 0;
}