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

struct Counter {
    long long a;
    long long b;
};

void increment(long long& val) {
    for (int i = 0; i < 100'000'000; i++) val++;
}

int main() {
    Counter cnt{ 0, 0 };
    auto start = std::chrono::high_resolution_clock::now();

    std::thread t1(increment, std::ref(cnt.a));
    std::thread t2(increment, std::ref(cnt.b));
    t1.join(); t2.join();

    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
    return 0;
}

#include <cstdlib>
#include <iostream>

void dummy_handler() {
    static int counter = 0;
    std::cout << "Handler " << ++counter << "\n";
}

int main() {
    // Регистрируем 100 обработчиков
    for (int i = 0; i < 100; ++i) {
        if (std::atexit(dummy_handler) != 0) {
            std::cerr << "Failed at " << i << "\n";
            return 1;
        }
    }
    
    std::cout << "All registered!\n";
    return 0;
}

#include <string>
#include <iostream>

struct Token {
    std::string value;
    const char* ptr;

    Token(const std::string& s) : value(s), ptr(value.data()) {}
};

int main() {
    Token t1("hi");
    Token t2 = t1; // копируем

    std::cout << t1.ptr << "\n"; // "hi"
    std::cout << t2.ptr << "\n"; // ???
}

#include <ranges>
#include <vector>

void process(const auto& view) {
    for (auto x : view) { (void)x; }
}

int main() {
    std::vector<int> data = { 1, 2, 3, 4, 5 };
    auto pred = [](int x) { 
        return x % 2 == 0; 
        };

    auto filtered = data | std::views::filter(pred);
    process(filtered); // ❌ не компилируется
}

#include <string>
#include <string_view>

// Вариант А
class LoggerA {
public:
    void log(const std::string& msg);
    void setPrefix(const std::string& prefix);
    std::string getLastMessage() const;
};

// Вариант Б
class LoggerB {
public:
    void log(std::string_view msg);
    void setPrefix(std::string_view prefix);
    std::string_view getLastMessage() const;
};

// Контекст использования:
// 1. log() вызывается тысячи раз в секунду
// 2. setPrefix() — один раз при старте
// 3. getLastMessage() — для диагностики
// 4. Логгер хранит последнее сообщение внутри

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

int main() {
    std::vector<int> vec = { 5, 3, 1, 4, 2 };

    auto sorted_view = vec
        | std::views::transform([](int x) { return x; });

    std::ranges::sort(sorted_view);

    for (auto v : sorted_view) {
        std::cout << v << " ";
    }
}

#include <mutex>
#include <thread>
#include <vector>
#include <iostream>

std::mutex mtx;
std::vector<int> data;

void producer() {
    for (int i = 0; i < 100; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push_back(i);
    }
}

void consumer() {
    while (true) {
        std::lock_guard<std::mutex> lock(mtx);
        if (data.empty()) {
            // Ждём данные...
            std::this_thread::sleep_for(
                std::chrono::milliseconds(10));
            continue;
        }
        std::cout << data.back() << "\n";
        data.pop_back();
    }
}