class EventQueue final {
public:
    static constexpr std::size_t kMaxEventsPerTick = 16U;

    [[nodiscard]] bool try_push(std::uint16_t event) noexcept {
        if(this->count_ >= kMaxEventsPerTick) {
            ++this->overflow_count_;  // 溢出了就计数，别崩
            return false;
        }
        this->events_[this->count_] = event;
        ++this->count_;
        return true;
    }

    void clear() noexcept { this->count_ = 0U; }
    [[nodiscard]] std::size_t size() const noexcept { return this->count_; }

private:
    std::array<std::uint16_t, kMaxEventsPerTick> events_{};
    std::size_t count_{0U};
    std::uint32_t overflow_count_{0U};  // 记录溢出次数，调试用
};

template <typename T>
concept HardwarePlatform = requires(T p) {
    { p.initialize() } noexcept -> std::same_as<bool>;
    { p.read_inputs() } noexcept;
    { p.write_outputs() } noexcept;
};

template <HardwarePlatform P>
void run_tick(P& platform) noexcept {
    platform.read_inputs();
    platform.write_outputs();
}

[[nodiscard]] bool build_status_line(std::span<char> out) noexcept {
    if(out.size() < 8U) { return false; }
    out[0] = 'O';
    out[1] = 'K';
    return true;
}

struct task_sequencer
{
    task_sequencer(winrt::DispatcherQueue const& queue = nullptr)
    : m_queue(queue) {}

    template<typename Maker>
    auto QueueTaskAsync(Maker&& maker) ->decltype(maker())
    {
        auto task = [&]() -> Async
        {
            completer completer{ current };
            auto local_maker = std::forward<Maker>(maker);
            auto local_queue = m_queue;

            co_await suspend;
            if (m_queue == nullptr) {
                co_await winrt::resume_background();  // 切到后台线程
            } else {
                co_await winrt::resume_foreground(local_queue);  // 或者切到指定队列
            }
            co_return co_await local_maker();
        }();
        // ...
    }
};

std::expected<uint32_t, parse_error> parse_manual_unrolled(const char *p, const char *pend) {
    uint32_t ip = 0;
    int octets = 0;
    while (p < pend && octets < 4) {
        uint32_t val = 0;
        if (p < pend && *p >= '0' && *p <= '9') {
            val = (*p++ - '0');
            if (p < pend && *p >= '0' && *p <= '9') {
                if (val == 0) {  // 01.02这种不合法
                  return std::unexpected(invalid_format);
                }
                val = val * 10 + (*p++ - '0');
                if (p < pend && *p >= '0' && *p <= '9') {
                    val = val * 10 + (*p++ - '0');
                    if (val > 255) {  // 超过255不行
                      return std::unexpected(invalid_format);
                    }
                }
            }
        } else {
            return std::unexpected(parse_error::invalid_format);
        }
        ip = (ip << 8) | val;
        octets++;
        if (octets < 4) {
            if (p == pend || *p != '.') {
              return std::unexpected(invalid_format);
            }
            p++;
        }
    }
    if (octets == 4 && p == pend) {
        return ip;
    } else {
        return std::unexpected(invalid_format);
    }
}

template <typename T>
class vector {
private:
    T* m_data;
    std::size_t m_size;       // 实际元素数量
    std::size_t m_capacity;   // 容量
};

void reserve(size_type new_capacity){
    if(new_capacity <= capacity()) return;
    auto ptr = allocate_helper(new_capacity);  // 先分配新内存
    try {
        copy_old_storage_to_new(m_data, m_size, ptr);  // 拷贝可能抛异常
    } catch(std::exception& ex){
        deallocate_helper(ptr);  // 失败了释放新内存
        throw;  // 继续抛，对象状态不变
    }
    std::destroy(m_data, m_data + m_size);  // 成功了才销毁旧数据
    deallocate_helper(m_data);
    m_data = ptr;
    m_capacity = new_capacity;
}

auto local = std::chrono::local_time<std::chrono::minutes>{ ... };
auto tz = std::chrono::locate_zone("Europe/Berlin");
auto sys_time = tz->to_sys(local);  // 转成系统时间

template<typename ForwardIt>
void rotate_adjacent(ForwardIt first, ForwardIt mid, ForwardIt last) {
    if (first == mid || mid == last) return;

    auto p = first;
    auto q = mid;

    while (true) {
        std::iter_swap(p++, q++);  // 交换元素

        if (p == mid) {
            // 块A用完了，块B还有剩余
            if (q == last) return;  // 都用完了
            mid = q;  // 递归处理剩余的
        } else if (q == last) {
            // 块B用完了，块A还有剩余
            // 递归处理剩余的
            return rot...

for (auto i = 0; i <= vec.size(); ++i)  // 应该是 <，不是 <=
  use(vec[i]);

for (Record const& rec : records)
  use(rec);

using std::views::reverse;

for (Record const& rec : reverse(records))
  use(rec);

using std::views::zip;

for (auto [name, rec] : zip(names, records))
  use(name, rec);

using std::views::iota;
using std::views::zip;

for (auto [i, rec] : zip(iota(0), records))
  use(i, rec);

using std::views::enumerate;

for (auto [i, rec] : enumerate(records))
  use(i, rec);

// 复杂索引计算
for (int i = 0; i != records.size(); i = records[i])
  use(records[i]);

struct key_less {
  bool operator()(T const& lhs, T const& rhs) const {
    return lhs.key < rhs.key;
  }
};

std::sort(c.begin(), c.end(), key_less{});

struct indirect_less {
  indirect_less(std::vector<int> const& indirection)
  : indirection_(indirection) {}

  bool operator()(T const& lhs, T const& rhs) const {
    return indirection_[lhs.key] < indirection_[rhs.key];
  }

private:
  std::vector<int> const& indirection_;
};

auto indirect_less = [&](T const& lhs, T const& rhs) {
  return indirection[lhs.key] < indirection[rhs.key];
};

auto make_indirect_less(std::vector const& indirection) {
  return [&](T const& lhs, T const& rhs) {
    return indirection[lhs.key] < indirection[rhs.key];
  };
}

constexpr int log10_2_sig = 315'653;
constexpr int log10_2_exp = 20;

auto floor_log10_pow2(int e) noexcept -> int {
  return e * log10_2_sig >> log10_2_exp;
}

inline auto divmod100(uint32_t value) noexcept -> divmod_result {
  assert(value < 10'000);
  constexpr int exp = 19;
  constexpr int sig = (1 << exp) / 100 + 1;
  uint32_t div = (value * sig) >> exp;
  return {div, value - div * 100};
}

constexpr std::size_t N = 1000;

std::vector<double> A_data(N * N);
std::vector<double> B_data(N * N);
std::vector<double> C_data(N * N);

std::random_device rd{};
std::mt19937 rng(rd());
std::uniform_real_distribution<double> dist(-1000, 1000);

for (auto& v : A_data) v = dist(rng);
for (auto& v : B_data) v = dist(rng);

void naive_multiplication(std::vector<double> const & A,
                         std::vector<double> const & B,
                         std::vector<double> & C,
                         std::size_t const N)
{
   for (std::size_t i = 0; i < N; ++i) {
      for (std::size_t j = 0; j < N; ++j) {
         C[i * N + j] = 0;
         for (std::size_t k = 0; k < N; ++k) {
            C[i * N + j] += A[i * N + k] * B[k * N + j];
         }
      }
   }
}

void naive_optimized_multiplication(std::vector<double> const& A,
                                    std::vector<double> const& B,
                                    std::vector<double>& C,
                                    std::size_t const N)
{
   for (std::size_t i = 0; i < N; ++i) {
      for (std::size_t j = 0; j < N; ++j) {
         double sum = 0;
         for (std::size_t k = 0; k < N; ++k) {
            sum += A[i * N + k] * B[k * N + j];
         }
         C[i * N + j] = sum;
      }
   }
}

void parallelized_multiplication(std::vector<double> const& A,
                                 std::vector<double> const& B,
                                 std::vector<double>& C,
                                 std::size_t const N)
{
   std::vector<std::size_t> rows(N, 0);

   std::for_each(
      std::execution::par,
      rows.begin(), rows.end(),
      [&](std::size_t i) {
         for (std::size_t j = 0; j < N; ++j) {
            double sum = 0;
            for (std::size_t k = 0; k < N; ++k)
               sum += A[i * N + k] * B[k * N + j];
            C[i * N + j] = sum;
         }
      });
}

#pragma comment(lib,"libopenblas.lib")
#include "cblas.h"

void openblas_multiplication(std::vector<double> const& A,
                             std::vector<double> const& B,
                             std::vector<double>& C,
                             blasint const N)
{
   cblas_dgemm(
      CblasRowMajor,
      CblasNoTrans,
      CblasNoTrans,
      N, N, N,
      1.0,
      A.data(), N,
      B.data(), N,
      0.0,
      C.data(), N
   );
}

#include <linalg>
#include <mdspan>
#include <vector>

void linalg_multiplication(std::vector<double> const& A,
                           std::vector<double> const& B,
                           std::vector<double>& C,
                           std::size_t const N)
{
   std::mdspan A_view(A.data(), N, N);
   std::mdspan B_view(B.data(), N, N);
   std::mdspan C_view(C.data(), N, N);

   std::linalg::matrix_product(A_view, B_view, C_view);
}

int sum_values(std::vector<int> const& values, bool squared) {
    int s...

template<typename T>
constexpr std::remove_reference_t<T>&& move(T&& t) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(t);
}

struct A {
    std::string s;

    A(std::string str) : s(std::move(str)) {
        // str被move后，依然是有效的lvalue
        std::cout << str.length() << '\n';  // 打印0，已被移走
    }
};

void process(const std::string& s) {
    std::string local = std::move(s);  // 没用！const对象不能移动
}

std::string get_string() {
    std::string s = "hello";
    return std::move(s);  // 画蛇添足！阻止了NRVO优化
}

bool is_leap_year(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

bool is_leap_year_fast(int year) {
    return (year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0);
}

bool is_leap_year_optimized(int year) {
    // 快速路径：大多数年份能被4整除但不是100的倍数
    if ((year & 3) != 0) return false;

    unsigned int mod25 = year % 25;
    if (mod25 != 0) return true;

    // 慢速路径：检查400的倍数
    return (year & 15) == 0;
}

std::vector<int> filter_even_raw_loop(const std::vector<int>& input) {
    std::vector<int> result;
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] % 2 == 0) {
            result.push_back(input[i]);
        }
    }
    return result;
}

std::vector<int> filter_even_range_for(const std::vector<int>& input) {
    std::vector<int> result;
    for (int val : input) {
        if (val % 2 == 0) {
            result.push_back(val);
        }
    }
    return result;
}

std::vector<int> filter_even_copy_if(const std::vector<int>& input) {
    std::vector<int> result;
    std::copy_if(input.begin(), input.end(),
                 std::back_inserter(result),
                 [](int x) { return x % 2 == 0; });
    return result;
}

void filter_even_erase_remove(std::vector<int>& vec) {
    vec.erase(std::remove_if(vec.begin(), vec.end(),
                             [](int x) { return x % 2 != 0; }),
              vec.end());
}

// Views - 惰性求值
auto filter_even_view(const std::vector<int>& input) {
    return input | std::views::filter([](int x) { return x % 2 == 0; });
}

// 转换回vector
std::vector<int> filter_even_ranges(const std::vector<int>& input) {
    auto filtered = input | std::views::filter([](int x) { return x % 2 == 0; });
    return std::vector<int>(filtered.begin(), filtered.end());
}

// C++23 ranges::to
std::vector<int> filter_even_ranges_to(const std::vector<int>& input) {
    return input
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::ranges::to<std::vector>();
}

std::vector<int> filter_even_parallel(const std::vector<int>& input) {
    std::vector<int> result;
    std::copy_if(std::execution::par,
                 input.begin(), input.end(),
                 std::back_inserter(result),
                 [](int x) { return x % 2 == 0; });
    return result;
}

void process_array(int* arr, size_t n) {
    for (size_t i = 0; i < n; ++i) {
        arr[i] = arr[i] * 2 + 1;
    }
}

template<size_t N>
void process_array_fixed(int (&arr)[N]) {
    for (size_t i = 0; i < N; ++i) {
        arr[i] = arr[i] * 2 + 1;
    }
}

// N=4时，编译器生成：
arr[0] = arr[0] * 2 + 1;
arr[1] = arr[1] * 2 + 1;
arr[2] = arr[2] * 2 + 1;
arr[3] = arr[3] * 2 + 1;

// 原循环
for (size_t i = 0; i < 1000; ++i) {
    process(i);
}

// 编译器展开成4路并行
for (size_t i = 0; i < 1000; i += 4) {
    process(i);
    process(i+1);
    process(i+2);
    process(i+3);
}

void session(Socket sock){
  char buffer[1024];
  int len = sock.read({buffer});
  sock.write({buffer,len});
  log(buffer);
}

Task<void> session(Socket sock){
  char buffer[1024];
  int len = co_await sock.async_read({buffer});
  co_await sock.async_write({buffer,len});
  log(buffer);
}

#include <coroutine>
#include <print>

struct Task{
  struct promise_type{
    Task get_return_object(){
      std::println("get_return_object()");
      return Task{ *this };
    }
    void return_void() noexcept {
      std::println("return_void()");
    }
    void unhandled_exception() noexcept {
      std::println("unhandled_exception()");
    }
    std::suspend_always initial_suspend() noexcept {
      std::println("initial_suspend()");
      return {};
    }
    std::suspend_always final_suspend() noexcept{
      std::println("final_suspend()");
      return {};
    }
  };
  explicit Task(promise_type&){
    std::println("Task(promise_type&)");
  }
  ~Task() noexcept{
    std::println("~Task()");
  }
};

Task coro_func(){
  co_return;
}

int main(){
  coro_func();
}

#include <coroutine>
#include <print>
#include <iostream>
#include <string>

struct Task{
  struct promise_type{
    std::string output_data{};

    Task get_return_object(){
      return Task{ *this };
    }
    void return_void() noexcept {}
    void unhandled_exception() noexcept {}
    std::suspend_always initial_suspend() noexcept{ return {}; }
    std::suspend_always final_suspend() noexcept{ return {}; }

    std::suspend_always yield_value(std::string msg) noexcept{
      output_data = std::move(msg);
      return {};
    }
  };

  std::coroutine_handle<promise_type> handle{};

  explicit Task(promise_type& promise)
  : handle { std::coroutine_handle<promise_type>::from_promise(promise) }
  {}

  ~Task() noexcept{
    if(handle)
      handle.destroy();
  }

  std::string get(){
    if(!handle...

// 错误1：off-by-one错误
for (auto i = 0; i <= vec.size(); ++i)  // 应该是 <，不是 <=
  use(vec[i]);

// 错误2：嵌套循环中修改错误的变量
for (auto i = 0; i != widths.size(); ++i)
  for (auto j = 0; j != heights.size(); ++i)  // 应该是 ++j
    use(widths[i], heights[j]);

// 错误3：无符号数反向迭代的陷阱
for (auto i = vec.size() - 1; i >= 0; --i)  // i永远 >= 0，死循环！
  use(vec[i]);

// 1. 基于范围的循环（最安全的简单情况）
for (Record const& rec : records)
  use(rec);

// 2. 反向迭代（C++20）
using std::views::reverse;
for (Record const& rec : reverse(records))
  use(rec);

// 3. 多个序列同时迭代（C++23）
using std::views::zip;
for (auto [name, rec] : zip(names, records))
  use(name, rec);

// 4. 带索引的迭代
using std::views::iota;
using std::views::zip;
for (auto [i, rec] : zip(iota(0), records))
  use(i, rec);

// 5. C++23简写 - enumerate
using std::views::enumerate;
for (auto [i, rec] : enumerate(records))
  use(i, rec);

void Assert(bool condition, std::string_view msg,
            std::string_view function, int line) {
  if(not condition) {
    std::clog << function << ':' << line
              << ": " << msg << '\n';
  }
}

#define ASSERT(condition, msg) \
  Assert(condition, msg, __FUNCTION__, __LINE__)

void Assert(bool condition, std::string_view msg,
            std::source_location location =
              std::source_location::current()) {
  if(not condition) {
    std::clog << location.function_name() << ':'
              << location.line() << ": " << msg << '\n';
  }
}

// 使用时不需要宏：
Assert(1 != 2, "Not met");

struct A {
    int x_;
    A(int x) : x_(x) {}
};

struct B : A {
    int y_;
    B(int x, int y) : A(x), y_(y) {}
};

int main() {
    B b{5, 3};
    A a = b;  // 切片发生！y_ 丢失了
}

struct A {
    int x_;
    A(int x) : x_(x) {}

    template <typename T, typename = std::enable_if_t<
        std::is_base_of_v<A, T> && !std::is_same_v<A, T>>>
    A(const T&) = delete;

    template <typename T, typename = std::enable_if_t<
        std::is_base_of_v<A, T> && !std::is_same_v<A, T>>>
    A& operator=(const T&) = delete;

    // 同样需要删除移动操作
};

template <typename T>
struct DontSlice {
    DontSlice() = default;
    DontSlice(const derived_from<T> auto&) = delete;
    DontSlice& operator=(const derived_from<T> auto&) = delete;
    DontSlice(derived_from<T> auto&&) = delete;
    DontSlice& operator=(derived_from<T> auto&&) = delete;
};

struct A : DontSlice<A> {
    int x_;
    A(int x) : x_(x) {}
    using DontSlice<A>::DontSlice;
};

template<class T>
struct AtomicRef {
  explicit AtomicRef(T&);
  MAYBE_EXPLICIT AtomicRef(T&&) = delete;
};

struct X {
  X(int);
};

void f(AtomicRef<const int>);
void f(X);

void test() {
  f(42);
}

auto ymdOct = std::chrono::year{1996} / 10 / 31;  // 1996年10月31日
auto ym = std::chrono::year{2025} / 11;            // 2025年11月
auto mw = 11 / std::chrono::Monday[3];             // 11月的第3个星期一

// day操作
std::chrono::day oneDay{7};
oneDay += std::chrono::days(20);  // 结果为第27天

// month操作
std::chrono::month oneMonth{std::chrono::September};
oneMonth += std::chrono::months(20);  // 结果为5月

// year_month_day操作
std::chrono::year_month_day today{std::chrono::year{2025}/11/22};
auto future = today + std::chrono::years{10};  // 2035-11-22
auto result = future - std::chrono::months{120};  // 2025-11-22

// weekday操作（使用模运算）
std::chrono::weekday aday = std::chrono::Sunday;
aday += std::chrono::days{22};
std::chrono::days diff = std::chrono::Monday - std::chrono::Tuesday;  // 6天

namespace chr = std::chrono;
const auto today = chr::sys_days{chr::floor<chr::days>(chr::system_clock::now())};
auto importantDate = chr::year{2011} / chr::July / 21;
const auto delta = (today - chr::sys_days{importantDate}).count();
std::print("{} was {} days ago!\n", importantDate, delta);

template<bool debugging>
struct WidgetT { /* ... */ };

#ifdef EXTRA_WIDGET_DEBUGGING
using Widget = WidgetT<true>;
#else
using Widget = WidgetT<false>;
#endif

void session(Socket sock) {
  auto s = make_shared<State>(move(sock));
  exec.async_read(s->sock, s->buffer, [s](error_code ec, int len) {
    if (!ec)
      exec.async_write(s->sock, {s->buffer, len}, [s](error_code ec, int) {
        if (!ec) finish(s);
      });
  });
}

task<void> session(Socket sock) {
  Buffer buffer;
  int len = co_await exec.co_read(sock, buffer);
  co_await exec.co_write(sock, {buffer, len});
  finish();
}

class Session : public enable_shared_from_this<Session> {
  void operator()() {
    exec.async_read(_s->sock, _s->buffer,
      [shared_from_this()](error_code ec, int len) {
        on_read(ec, len);
      });
  }
};

// libfoo.h:
int foo(std::function_ref<int(float)>);

// app.cpp:
void something() {
  // 存储 lambda 对象 -> 间接调用：
  foo([](float x) { return int(x * 0.5); });

  // 函数指针为 nullptr -> 直接调用：
  foo(std::constant_arg<[](float x) { return int(x * 0.5); }>);
}

const auto ret = cpp::some_operation( ... );

if ( ret ) // 编译失败！enum class 无法隐式转换为 bool

if ( ret == cpp::result::Success )  // 可以工作，但更繁琐，我不喜欢打这么多字

enum class Result {
    Success = 0,
    SomeError,
    SomeOtherError
};
// 编译失败！不能将 operator bool 定义为静态函数
inline explicit operator bool(Result r) { return r != Result::Success; } 

inline bool operator!(Result r) { return r == Result::Success; }

void foo()
{
  const Result ret = cpp::some_operation( ... );
  if ( !!ret ) 
  {
    // 处理错误
  }
}

struct Result {
    enum class Value {
        Success = 0,
        SomeError,
        SomeOtherError
    } v;

    explicit operator bool() const { return v != Result::Value::Success; }
};

void bar()
{
    const Result ret = cpp::some_operation( /* ... */ );
    if ( ret.v == Result::Value::SomeError ) {} // 可以工作
    if ( ret.v == 42 ) {} // 编译错误
}

struct Result {
    enum class Value {
        Success = 0,
        SomeError,
        SomeOtherError
    } v;

    constexpr Result( Value x ) : v( x ) {}
    constexpr explicit operator bool() const { return v != Result::Success; }

    static constexpr Value Success = Value::Success;
    static constexpr Value SomeError = Value::SomeError;
    static constexpr Value SomeOtherError = Value::SomeOtherError;
    // 对枚举中的每个值重复此操作
};

inline constexpr bool operator==( Result lhs, Result rhs ) { return lhs.v == rhs.v; }
inline constexpr bool operator!=( Result lhs, Result rhs ) { return lhs.v != rhs.v; }

void foo()
{
    const Result ret = cpp::some_operation( /* ... */ );
    if ( ret ) {} // 可以工作
    if ( ret == Result::SomeError ) {} // 同样可以工作
    if ( ret.v == 42 ) {} // 编译错误
}

template<typename T>
bool compare_same(const T& a, const T& b) {
    template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
        if (!compare_same(a.[:mem:], b.[:mem:])) {
            return false;
        }
    }
    return true;
}

class TreeNode {
public:
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int value) : data(value), left(nullptr), right(nullptr) {}
};

class BinaryTreeOptional {
private:
    int root = -1;
    std::vector<std::optional<TreeNodeOptional>> nodes;

    size_t insertRecursive(int node, int value) {
        if (node == -1) {
            nodes.emplace_back(value);
            return nodes.size() - 1;
        }

        auto node_value = nodes[node]->data;
        if (value < node_value) {
            nodes[node]->left = insertRecursive(nodes[node]->left, value);
        } else if (value > node_value) {
            nodes[node]->right = insertRecursive(nodes[node]->right, value);
        }

        return node;
    }

    void inOrderRecursive(std::optional<TreeNodeOptional>& onode) {
        if (onode.has_value()) {
            auto& node = onode.value();
            if (node.left != -1)
                inOrderRecursive(nodes[node.left]);
            if (node.right != -1)
                inOrderRecursive(nodes[node.right]);
        }
    }

public:
    void insert(int value) {
        root = insertRecursive(root, value);
    }

    void inOrderTraversal() {
        if (root != -1)
            inOrderRecursive(nodes[root]);
    }
};

#include <bit>
int utf8_sequence_length(unsigned char lead_byte) {
    switch (std::countl_one(lead_byte)) {
        case 0: return 1;
        case 2: return 2;
        case 3: return 3;
        case 4: return 4;
        default: return 0; // 无效首字节
    }
}

template <callable ...Fs, typename ...Args>
auto call_by_need(some<Fs...>, some<Args...>);

#include <iostream>
#include <string_view>
#include <vector>

template <typename Message>
class Subscriber {
   public:
    virtual ~Subscriber() = default;
    virtual void update(Message message) = 0;
};

template <typename Message>
class Publisher {
   public:
    virtual ~Publisher() = default;
    void subscribe(Subscriber<Message>* subscriber) {
        std::cout << "Got a new subscriber\n";
        _subscribers.push_back(subscriber);
    }

    void unsubscribe(Subscriber<Message>* subscriber) {
        std::cout << "Someone unsubscribed\n";
        std::erase(_subscribers, subscriber);
    }

   protected:
    void notify(Message message) const {
        std::cout << "Sending an update to " << _subscribers.size()
                  << " subscriber(s)\n";
        for (auto* const subscriber : _subscribers) {
            notifyOne(subscriber, message);
        }
    }

   private:
    virtual void notifyOne(Subscriber<Message>* const,
                           Message message) const = 0;

    std::vector<Subscriber<Message>*> _subscribers;
};

using SettingsMessage = std::pair<std::string, int>;
class SettingsSubscriber : public Subscriber<Settings...

// 改进前
std::vformat(str, std::make_format_args(42));

// 改进后：更清晰的意图表达
std::format(std::runtime_format(str), 42);

std::string str = "{}";
auto args = std::make_format_args(path.string());  // 临时对象被移动
std::string msg = std::vformat(str, args);        // 使用已销毁的临时对象

for (char c : "\U0001F937") {  // Unicode 字符 "🤷"
  std::print("\\x{:02x}", c);  // 可能输出 \x-10 或 \xf0
}

// 内部实现修改示例
template<>
struct formatter<char> {
    auto format(char c, auto& ctx) {
        return formatter<unsigned char>::format(+c, ctx);  // 显式转换为无符号
    }
};

std::cout << std::format("{:?}", path);  // "multi\nline"

#include <format>
#include <iostream>
#include <string>

struct ProgrammingLanguage {
    std::string name;
    int version{0};
};

template <>
struct std::formatter<ProgrammingLanguage> {
    std::formatter<std::string> _formatter;
    constexpr auto parse(std::format_parse_context& parse_context) {
        return _formatter.parse(parse_context);
    }

    auto format(const ProgrammingLanguage& programming_language,
                std::format_context& format_context) const {
        std::string output = std::format("{}{}", programming_language.name,
                                         programming_language.version);
        return _formatter.format(output, format_context);
    }
};

int main() {
    ProgrammingLanguage cpp{"C++", 20};
    std::cout << std::format("{} is fun", cpp) << '\n';
}

template <>
struct std::formatter<ProgrammingLanguage> {
    std::string _attributes;
    constexpr auto parse(std::format_parse_context& parse_context) {
        auto it = std::ranges::find(parse_context, '}');
        _attributes = std::string(parse_context.begin(), it);
        return it;
    }

    auto format(const ProgrammingLanguage& programming_language,
                std::format_context& format_context) const {
        auto out = format_context.out();
        if (_attributes.empty()) {
            out = std::format_to(out, "{}{}", programming_language.name,
                                 programming_language.version);
            return out;
        }
        for (auto n = 0u; n <= _attributes.size(); ++n) {
            if (_attributes[n] == '%') {
                switch (_attributes[++n]) {
                    case 'n':
                        out = std::format_to(out, "{}",
                                             programming_language.name);
                        break;
                    case 'v':
                        out = std::format_to(out, "{}",
                                             programming_language.version);
                        break;
                    case '%':
                        out = std::format_to(out, "%");
                        break;
                }
            } else {
                out = std::format_to(out, "{}", _attributes[n]);
            }
        }
        return out;
    }
};

#include <format>
#include <optional>
#include <string>

struct ProgrammingLanguage {
    std::string name;
    int major_version{0};
    std::optional<int> minor_version{};
    std::optional<int> patch_version{};
};

template <>
struct std::formatter<ProgrammingLanguage> {
    std::string _attributes;
    
    constexpr auto parse(std::format_parse_context& ctx) {
        auto it = std::ranges::find(ctx, '}');
        _attributes = std::string(ctx.begin(), it);
        return it;
    }

    auto format(const ProgrammingLanguage& pl, std::format_context& ctx) const {
        auto out = ctx.out();
        if (_attributes.empty()) {
            return std::format_to(out, "{}{}", pl.name, pl.major_version);
        }
        for (size_t n = 0; n < _attributes.size(); ++n) {
            if (_attributes[n] == '%') {
                ++n;
                switch (_attributes[n]) {
                    case 'l': 
                        std::format_to(out, "{}", pl.name); 
                        break;
                    case 'v': {
                        std::format_to(out, "{}", pl.major_version);
                        if (auto m = pl.minor_version) 
                            std::format_to(out, ".{}", *m);
                        if (auto p = pl.patch_version) 
                            std::format_to(out, ".{}", *p);
                        break;
                    }
                    case 'm': 
                        std::format_to(out, "{}", pl.major_version); 
                        break;
                    case 'n': 
                        std::format_to(out, "{}", *pl.minor_version); 
                        break;
                    case 'p': 
                        std::format_to(out, "{}", *pl.patch_version); 
                        break;
                }
            } else {
                std::format_to(out, "{}", _attributes[n]);
            }
        }
        return out;
    }
};

// Windows 平台专用实现
struct cheap_steady_clock {
    using rep = int64_t;              // 支持负时间差
    using period = std::milli;        // 毫秒单位
    using duration = std::chrono::duration<rep, period>;
    using time_point = std::chrono::time_point<cheap_steady_clock>;

    static constexpr bool is_steady = true;  // 保证单调递增

    static time_point now() noexcept {
        return time_point{ duration{ static_cast<int64_t>(GetTickCount64()) } };
    }
};

// Linux 平台专用实现
struct cheap_steady_clock {
    using duration = std::chrono::nanoseconds;  // 保持纳秒类型兼容性
    using rep = duration::rep;
    using period = duration::period;
    using time_point = std::chrono::time_point<cheap_steady_clock>;

    static constexpr bool is_steady = true;

    static time_point now() noexcept {
        struct timespec tp;
        if (0 != clock_gettime(CLOCK_MONOTONIC_COARSE, &tp))
            throw system_error(errno, "clock_gettime failed");
        return time_point(std::chrono::seconds(tp.tv_sec) + std::chrono::nanoseconds(tp.tv_nsec));
    }
};

namespace std {
    template <typename T>
    std::ostream &operator<<(std::ostream &os, const optional<T> &value) {
        if (value.has_value()) {
            return os << "std::optional{" << value.value() << "}";
    }
        return os << "std::nullopt";
    }
} // namespace std

namespace boost::test_tools::tt_detail {
template <typename T>
struct print_log_value<std::optional<T>> {
  void operator()(std::ostream &os, const std::optional<T> &value) {
    if (value.has_value()) {
      os << "std::optional{";
      print_log_value<T>()(os, *value);
      os << "}";
    } else {
      os << "std::nullopt";
    }
  }
};
}  // namespace boost::test_tools::tt_detail

template<typename T>
consteval std::string generate_sql_columns() {
    std::string columns;
    bool first = true;

    constexpr auto ctx = std::meta::access_context::current();

    [:expand(std::meta::nonstatic_data_members_of(^^T, ctx)):] 
                        >> [&]<auto member>{
            using member_type = typename[:type_of(member):];
            if (!first) {
                columns += ", ";
            }
            first = false;

            // Get member name
            auto name = std::meta::identifier_of(member);
            columns += name;
    };

    return columns;
}
template<typename T>
constexpr std::string generate_sql_valuess(const T& obj) {
    std::string values;
    bool first = true;

    constexpr auto ctx = std::meta::access_context::current();

    [:expand(std::meta::nonstatic_data_members_of(^^T, ctx)):] 
                        >> [&]<auto member>{
        using member_type = typename[:type_of(member):];
        if (!first) {
            values += ", ";
        }
        first = false;

        // Get member value
        auto value = obj.[:member:];

        // Format value based on type
        if constexpr (std::same_as<member_type, std::string>) {
            // Escape single quotes in strings
            std::string escaped = value;
            size_t pos = 0;
            while ((pos = escaped.find('\'', pos)) 
                      != std::string::npos) {
                escaped.replace(pos, 1, "''");
                pos += 2;
            }
            values += "'" + escaped + "'";
        } else if constexpr (std::is_arithmetic_v<member_type>) {
            values += std::to_string(value);
        }
    };

    return values;
}
template<typename T>
constexpr std::string generate_sql_insert(const T& obj, const std::string& table_name) {
    constexpr std::string columns = generate_sql_columns<T>();
    std::string values = generate_sql_valuess(obj);
    return "INSERT INTO " + table_name 
          + " (" + columns + ") VALUES (" + values + ");";
}

template <class PB>
std::string ProtoToUpdateSql(PB pb, const std::string& table, const std::string& whereCondition) {
  std::vector<std::string> updateFields;

  // 使用反射获取所有字段
  const google::protobuf::Descriptor* descriptor = pb.GetDescriptor();
  const google::protobuf::Reflection* reflection = pb.GetReflection();

  for (int i = 0; i < descriptor->field_count(); i++) {
    const google::protobuf::FieldDescriptor* field = descriptor->field(i);

    // 跳过没有设置值的字段
    if (!reflection->HasField(pb, field)) {
      continue;
    }

    std::string fieldName = field->name();
    std::string value;

    // 根据字段类型获取值
    switch (field->cpp_type()) {
      case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
        value = std::to_string(reflection->GetInt32(pb, field));
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
        value = std::to_string(reflection->GetInt64(pb, field));
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
        value = std::to_string(reflection->GetUInt64(pb, field));
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
        value = std::to_string(reflection->GetDouble(pb, field));
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
        value = std::to_string(reflection->GetFloat(pb, field));
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
        value = reflection->GetBool(pb, field) ? "TRUE" : "FALSE";
        break;
      case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
        value = std::to_string(reflection->GetEnumValue(pb, field));
        break;
      default:
        value = "'" + ExtraString(reflection->GetString(pb, field)) + "'";
        break;
    }

    updateFields.push_back(fieldName + " = " + value);
  }

  // 如果没有字段需要更新，返回空字符串
  if (updateFields.empty()) {
    return "";
  }

  // 构建SQL语句
  std::stringstream ss;
  ss << "UPDATE " << table << " SET ";

  for (size_t i = 0; i < updateFields.size(); i++) {
    if (i > 0)
      ss << ", ";
    ss << updateFields[i];
  }

  ss << " WHERE " << whereCondition;

  return ss.str();
}

#include <iostream>
#include <string>

int main() {
    std::string a;
    std::string b;
    a.push_back(64);
    b.push_back(-28);
    char c = 64;
    char d = -28;
    std::cout << (a < b) << std::endl; // output 1
    std::cout << (c < d) << std::endl; // output 0
    return 0;
}

// https://godbolt.org/z/TK9WM65n1
#include <iostream>
#include <memory>

// sdk

class InterfaceForSomeServiceBase{
public:
    virtual ~InterfaceForSomeServiceBase() = default;
};

class InterfaceForSomeService_v1: public InterfaceForSomeServiceBase {
public:
	virtual void featureA() = 0;
	virtual void featureB() = 0;
};

class InterfaceForSomeService_v2 : public InterfaceForSomeService_v1 {
public:
	virtual void featureC() = 0;
};

class InterfaceForSomeService_v3 : public InterfaceForSomeService_v2 {
public:
	virtual void featureD() = 0;
};


class Server {
public:
    void handle(std::unique_ptr<InterfaceForSomeServiceBase> clientImplementation) {
        if (auto* p = dynamic_cast<InterfaceForSomeService_v3*>(clientImplementation.get()); p) {
            p->featureA();
            p->featureB();
            p->featureC();
            p->featureD();
        } else if (auto* p = dynamic_cast<InterfaceForSomeService_v2*>(clientImplementation.get()); p) {
            p->featureA();
            p->featureB();
            p->featureC();
        } else if (auto* p = dynamic_cast<InterfaceForSomeService_v1*>(clientImplementation.get()); p) {
            p->featureA();
            p->featureB();
        } else {
            std::cout << "unhandled version\n";
        }
    }
};


// client

class ClientServiceImplementation : public InterfaceForSomeService_v2 {
public:
	void featureA() override {
        std::cout << "ClientServiceImplementation(InterfaceForSomeService_v2)::featureA\n";
    }
	void featureB() override {
        std::cout << "ClientServiceImplementation(InterfaceForSomeService_v2)::featureB\n";
    }
    void featureC() override {
        std::cout << "ClientServiceImplementation(InterfaceForSomeService_v2)::featureC\n";
    }
};

// server

std::unique_ptr<InterfaceForSomeServiceBase> LoadFromDLL() {
    return std::make_unique<ClientServiceImplementation>();
}

int main() {
    std::unique_ptr<InterfaceForSomeServiceBase> clientImplementation = LoadFromDLL();

    Server s;
    s.handle(std::move(clientImplementation));
}

#include <iostream>
#define CONCAT(A, B) A ## B

int FooFunctionOne() {
    return 1;
}

int BarFunctionOne() {
    return -1;
}
template<int (*Func)()>
class UsesTemplates {
public:
    int CallFunction() {
        return Func();                              
    }
};

//  Example:  TEMPLATE_CLASS(Foo) -> UsesTemplates<&FooFunctionOne>
#define TEMPLATE_CLASS(PREFIX) UsesTemplates<&CONCAT(PREFIX, FunctionOne)>

int main() {
    TEMPLATE_CLASS(Foo) fooClass;   // Expands to UsesTemplates<&FooFunctionOne>
    TEMPLATE_CLASS(Bar) barClass;   // ...

#include <tuple>

template <typename... Ts>
class Storage {
   public:
    Storage(Ts&&... args) : elements(args...) {}

    // some getters here

   private:
    std::tuple<Ts...> elements;
};

template <typename... Ts>
Storage(Ts&&... ts) -> Storage<Ts...>;

int main() {
    auto myStore = Storage(41, 4.2, "forty two");
}

template<typename... Ts>
struct Visitor : Ts... {
	using Ts::operator()...;
};

auto v = Visitor{
    [](int i){ std::cout << i << '\n'; },
    [](float f){ std::cout << f << '\n'; },
    [](const std::string& s){ std::cout << s << '\n'; }
};

v(42); // prints 42

template<class... Ts>
class Foo {
  friend Ts...;
};

for(const auto& reg:registrations)

template<class ...Args >
QSqlQuery exec_sql(const QString& sql, Args... args)
{
    QSqlQuery query;
    query.prepare(sql);
    Q_ASSERT(query.boundValues().size() == sizeof...(args));
    bind_value(query,0, args...);
    if(!query.exec() && query.lastError().isValid())
        qWarning() << query.lastError().text()<< query.lastQuery();
    return query;
}

template<class ...Args>
QSqlQuery exec_sql(const QString& sql, Args... args) {
    QSqlQuery query;
    if (!query.prepare(sql)) {
        qWarning() << "PREPARE FAIL:" << query.lastError().text() 
                   << "| SQL:" << sql
                   << "| Driver:" << query.driver()->lastError().text();
    } else {
        Q_ASSERT(query.boundValues().size() == sizeof...(args));
        bind_value(query, 0, args...);
        if (!query.exec() && query.lastError().isValid())
            qWarning() << "EXEC FAIL:" << query.lastError().text();
  ...

Widget GetWidget() {
    if (!m_widget) {
        m_widget = std::make_unique<Widget>();
    }
    return m_widget.get(); // 这里有问题
}

return Widget(m_widget.get() != nullptr); 

if (!i.valueless_after_move()) 
    std::cout << *i;

for (size_t i { 0ULL }; i < pointers.size(); i++) {
    sum += vector[pointers[i]];
}

while(p < total_accesses) {
    sum += list[idx].value;
    idx = list[idx].next;
    
    if (idx == node_t::NULLPTR) {
        idx = 0U;
    }

    p++;
}

// 错误！阻止 NRVO 优化，强制降级为移动
return std::move(local_obj); 

// 正确：允许编译器优化（直接构造或自动移动）
return local_obj;          

class Widget {
    std::vector<int> data_;
public:
    auto getData() { 
        return std::move(data_); // 必须！避免拷贝
    }
};

#include <print>
#include <ranges>
#include <string_view>

int main() {
    using namespace std::string_view_literals;

    constexpr auto text = "C++ is powerful and elegant"sv;
    
    for (auto part : std::views::split(text, ' '))
        std::print("'{}' ", std::string_view(part));
}

  std::vector<int> data{1, 2, 3, 4, 5, 6, 7, 8};

  for (auto chunk : data | std::views::chunk(3))
      std::print("{}\n", chunk);

/*
[ 1 2 3 ]
[ 4 5 6 ]
[ 7 8 ]
*/

  std::vector<int> values{1, 3, 5, 2, 4, 6, 7, 9, 8};

  for (auto group : values | std::views::chunk_by([](int a, int b) {
      return (a % 2) == (b % 2); // Same parity
  })) {
      std::print("size {}, {}\n", group.size(), group);
  }
/*
size 3, [1, 3, 5]
size 3, [2, 4, 6]
size 2, [7, 9]
size 1, [8]
*/

template <typename T>
class Wrapper {
private:
    int secret = 42;

    template <typename U>
    friend class Wrapper; // Friend itself to allow specializations access

public:
    void showSecret() {
        std::cout << "Secret: " << secret << std::endl;
    }
};

template <>
class Wrapper<int> {
public:
    template <typename T> requires (!std::same_as<T, int>)
    void accessSecret(Wrapper<T>& w) {
        // Thanks to the friend declaration, this specialization can access private members
        std::cout << "Accessing: " << w.secret << std::endl;
    }
};

class Outer {
   public:
    class Inner {
        int secret = 42;

        friend class Outer;
    };

    void revealSecret(const Inner& inner) {
        std::cout << "Inner's secret is: " << inner.secret << '\n';
    }
};

#define dynamic_assert(cond, fmt, ...)                             \
    do {                                                           \
        if (cond) break;                                           \
        throw stack_runtime_error(std::format(fmt, __VA_ARGS__));  \
    } while (0)

#define dynamic_assert(...) dynamic_assert_impl(std::stacktrace::current(), __VA_ARGS__)

template<class... Args>
void dynamic_assert_impl(const std::stacktrace& st, bool cond, std::format_string<Args...> fmt, Args&&... args) {
    if (!cond) {
        throw stack_runtime_error(std::format(fmt, std::forward<Args>(args)...), st);
 

template <class Visitor, class Variant, std::size_t ... Is>
auto visit_impl(Visitor visitor, Variant && variant, std::index_sequence<Is...>) {
    auto i = variant.index();
    switch (i) { (case Is: return visitor(get<Is>(variant));)... }
}

template <auto> int h();

int mersenne(unsigned index){
  //.L4:
  constexpr static void* jtable[] = { 
    &&CASE_0,     //    .quad   .L8
    &&CASE_1,     //    .quad   .L7
    &&CASE_2,     //    .quad   .L6
    &&CASE_3,     //    .quad   .L5
    &&CASE_4,     //    .quad   .L3
  };

  // cmp     edi, 4
  if (index > 4) {   
    goto DEFAULT; // ja      .L2
  }

  // jmp     [QWORD PTR .L4[0+rdi*8]]
  goto* jtable[index];

CASE_0:           //.L8:
  return h<2>();  //    jmp     int h<2>()
CASE_1:           //.L7:
  return h<3>();  //    jmp     int h<3>()
CASE_2:           //.L6:
  return h<5>();  //    jmp     int h<5>()
CASE_3:           //.L5:
  return h<7>();  //    jmp     int h<7>()
CASE_4:           //.L3:
  return h<13>(); //    jmp     int h<13>()

//.L2:
//        mov     eax, -1
//        ret
DEFAULT: 
  return -1;
}

template <int... Is>
int visit(unsigned index) {
  using F = int();
  constexpr static F* table[] = {&h<Is>...};  

  if (index >= (sizeof table / sizeof* table)) {
    // 边界检查
    return -1;
  }
  return table[index]();
}

template <auto V>
int h();

template <typename F, typename V>
decltype(auto) visit(F&& visitor, V&& variant) {
  constexpr static auto max_index = std::variant_size_v<std::remove_cvref_t<V>>;
  constexpr static auto table = []<std::size_t... Idx>(std::index_sequence<Idx...>) {
    return std::array{+[](F&& visitor, V&& variant) {
      return std::invoke(std::forward<F>(visitor), 
                         __unchecked_get<Idx>(std::forward<V>(variant)));
    }...};
  }(std::make_index_sequence<max_index>());

  const auto index = variant.index();
  if (index >= table.size()) {
    // boundary check
    std::unreachable();
  }
  return table[index](std::forward<F>(visitor), std::forward<V>(variant));
}

template <int... Is>
int visit(unsigned index) {
  int retval;
  std::initializer_list<int>({(index == Is ? (retval = h<Is>()), 0 : 0)...});
  return retval;
}

template <int... Is>
int visit(unsigned index) {
  int value;
  (void)((index == Is ? value = h<Is>(), true : false) || ...);
  return value;
}

template <typename F, typename V>
using visit_result_t = std::invoke_result_t<F, std::variant_alternative_t<0, 
                                            std::remove_reference_t<V>>>;

template<typename F, typename V>
constexpr auto visit(F&& visitor, V&& variant){
  using return_type = visit_result_t<F, V>;
  constexpr auto size = std::variant_size_v<std::remove_cvref_t<V>>;
  return visit_impl<return_type>(std::make_index_sequence<size>(), 
                                 std::forward<F>(visitor), 
                                 std::forward<V>(variant));
}

template <typename R, typename F, typename V, std::size_t... Idx>
  requires (std::same_as<R, void>)
constexpr void visit_impl(std::index_sequence<Idx...>, F&& fnc, V&& variant) {
  auto index = variant.index();
  if(((index == Idx ? std::forward<F>(fnc)(get<Idx>(std::forward<V>(variant))), true 
                    : false) || ...)){
    // 找到
    return;
  }

  std::unreachable();
}