#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base constructor: ";
        call();
    }
    virtual void call() { cout << "Base::call\n"; }
};

class Derived : public Base {
    int x = init();

    int init() {
        cout << "Derived::init\n";
        return 42;
    }

public:
    Derived() {
        cout << "Derived constructor\n";
    }

    void call() override {
        cout << "Derived::call, x = " << x << "\n";
    }
};

int main() {
    Derived d;
    return 0;
}

Derived::init
Derived constructor

Derived::init
Derived constructor

Base constructor: Derived::call, x = 42
Derived constructor

Derived::call, x = <undefined>
Derived::init
Derived constructor

arr = [4, 7, 9, 2, 8, 3]

(2,3)
(4,3)
(4,7)
(8,7)
(8,9)

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor\n";
        foo();
    }
    virtual void foo() {
        std::cout << "Base foo\n";
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor\n";
    }
    void foo() override {
        std::cout << "Derived foo\n";
    }
};

int main() {
    Derived d;
    return 0;
}

#include <iostream>
#include <vector>

struct Foo {
    Foo() { std::cout << "Ctor\n"; }
    ~Foo() { std::cout << "Dtor\n"; }
    Foo(const Foo&) { std::cout << "Copy\n"; }
    Foo(Foo&&) noexcept { std::cout << "Move\n"; }
};

int main() {
    std::vector<Foo> v;
    v.reserve(3);  // Резервируем место под 3 элемента

    std::cout << "--- Pushing ---\n";
    for (int i = 0; i < 3; ++i) {
        v.push_back(Foo());
    }

    std::cout << "--- Done ---\n";
}

--- Pushing ---
Ctor
Move
Dtor
Ctor
Move
Dtor
Ctor
Move
Dtor
--- Done ---
Dtor
Dtor
Dtor

// Резервирует память, не создаёт объекты
v.reserve(10);

// Создаёт 10 объектов Foo
v.resize(10);

v.emplace_back();  // Вызывает конструктор Foo напрямую внутри вектора

int findMissingNumber(const std::vector<std::string>& data);

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

int findMissingNumber(const std::vector<std::string>& data) {
    int xor_full = 0;
    int xor_data = 0;

    for (int i = 1; i <= 100; ++i) {
        xor_full ^= i;
    }

    for (const auto& s : data) {
        xor_data ^= std::stoi(s);
    }

    return xor_full ^ xor_data;
}

int main() {
    std::vector<std::string> data;
    for (int i = 1; i <= 100; ++i) {
        if (i != 57) { // Удалим 57
            data.push_back(std::to_string(i));
        }
    }

    std::cout << "Пропущено: " << findMissingNumber(data) << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>

template<typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
process(T value) {
    std::cout << "Integral: " << value << std::endl;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
process(T value) {
    std::cout << "Floating-point: " << value << std::endl;
}

int main() {
    process(42);       // (1)
    process(3.14);     // (2)
    process('A');      // (3)
}

#include <iostream>
#include <type_traits>

template<typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
process(T value) {
    std::cout << "Integral: " << value << std::endl;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
process(T value) {
    std::cout << "Floating-point: " << value << std::endl;
}

int main() {
    process(42);       // (1)
    process(3.14);     // (2)
    process('A');      // (3)
}

#include <vector>
#include <cstring>

struct Packet {
    uint32_t id;
    char data[64];
};

std::vector<uint8_t> serialize(const Packet& p) {
    std::vector<uint8_t> buffer(sizeof(Packet));
    std::memcpy(buffer.data(), &p, sizeof(Packet));
    return buffer;
}

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

std::string identity(std::string&& s) {
    std::cout << "rvalue reference\n";
    return std::move(s);
}

std::string identity(const std::string& s) {
    std::cout << "const lvalue reference\n";
    return s;
}

int main() {
    const std::string a = "hello";
    std::string b = identity(std::move(a));
    std::cout << "Result: " << b << std::endl;
}

std::move(const std::string&) → const std::string&&

#include <iostream>
#include <cstdlib>
#include <memory>
#include <array>

void get_gpu_utilization() {
    std::array<char, 128> buffer;
    std::string result;

    std::unique_ptr<FILE, decltype(&pclose)> pipe(
        popen("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,nounits,noheader", "r"),
        pclose
    );

    if (!pipe) {
        std::cerr << "❌ Ошибка при вызове nvidia-smi" << std::endl;
        return;
    }

    int gpu_id = 0;
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        std::string line(buffer.data());
        size_t pos1 = line.find(',');
        size_t pos2 = line.rfind(',');

        std::string util = line.substr(0, pos1);
        std::string mem_used = line.substr(pos1 + 1, pos2 - pos1 - 1);
        std::string mem_total = line.substr(pos2 + 1);

        std::cout << "🖥 GPU " << gpu_id++ << ": " << util << "% load | "
                  << mem_used << " MiB / " << mem_total << " MiB";
    }
}

int main() {
    get_gpu_utilization();
    return 0;
}

#include <iostream>
#include <vector>
#include <unordered_map>

int main() {
    std::vector<std::string> items = {"apple", "banana", "apple", "orange", "banana", "apple"};
    std::unordered_map<std::string, int> freq;

    for (const auto& item : items) {
        ++freq[item];
    }

    for (const auto& [key, count] : freq) {
        std::cout << key << ": " << count << "\n";
    }
    // 👉 apple: 3, banana: 2, orange: 1
}

SafeCounter counter(1000); // сброс через 1000 мс
counter.increment();       // value = 1
std::this_thread::sleep_for(500ms);
counter.increment();       // value = 2, таймер сброса перезапускается
std::this_thread::sleep_for(1500ms);
std::cout << counter.get(); // value = 0

#include <iostream>
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <chrono>

class SafeCounter {
public:
    SafeCounter(int timeout_ms) : timeout(timeout_ms), value(0), stop(false) {
        worker = std::thread([this] { this->watch(); });
    }

    ~SafeCounter() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        worker.join();
    }

    void increment() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            ++value;
            last_action = std::chrono::steady_clock::now();
        }
        cv.notify_all();
    }

    int get() const {
        return value.load();
    }

private:
    void watch() {
        std::unique_lock<std::mutex> lock(mtx);
        while (!stop) {
            cv.wait_for(lock, timeout, [this] {
                return stop || std::chrono::steady_clock::now() - last_action >= timeout;
            });

            if (stop) break;

            if (std::chrono::steady_clock::now() - last_action >= timeout) {
                value = 0;
            }
        }
    }

    std::chrono::milliseconds timeout;
    std::chrono::steady_clock::time_point last_action = std::chrono::steady_clock::now();
    std::atomic<int> value;
    std::mutex mtx;
    std::condition_variable cv;
    std::thread worker;
    bool stop;
};

#include <type_traits>
#include <iostream>

// Пример предиката
template<typename T>
struct is_integral : std::is_integral<T> {};

int main() {
    using MyList = TypeList<int, char, float, double, short>;
    
    static_assert(MyList::length == 5);
    static_assert(std::is_same_v<MyList::at<0>, int>);
    static_assert(std::is_same_v<MyList::at<2>, float>);

    using WithBool = MyList::push_front<bool>;
    static_assert(WithBool::length == 6);
    static_assert(std::is_same_v<WithBool::at<0>, bool>);

    using Popped = WithBool::pop_front;
    static_assert(std::is_same_v<Popped, MyList>);

    static_assert(MyList::contains<int>);
    static_assert(!MyList::contains<bool>);

    using OnlyIntegral = MyList::filter<is_integral>;
    static_assert(std::is_same_v<OnlyIntegral, TypeList<int, char, short>>);

    return 0;
}