C++ 效能面試實戰：六道「誰比較快」

// 寫法 A：pass by value + move
struct Widget {
    std::string name;
    Widget(std::string n) : name{std::move(n)} {}
};

// 寫法 B：pass by string_view
struct Widget {
    std::string name;
    Widget(std::string_view n) : name{n} {}
};

// 寫法 C：pass by const reference
struct Widget {
    std::string name;
    Widget(const std::string& n) : name{n} {}
};

void process(std::string_view msg) {
    // 寫法 0：static + capture by reference
    static const auto fn0 = [&]() {
        std::cout << msg << "\n";
    };
    fn0();
}

void process(std::string_view msg) {
    // 寫法 1：non-static + capture by reference
    const auto fn1 = [&]() {
        std::cout << msg << "\n";
    };
    fn1();
}

void process(std::string_view msg) {
    // 寫法 2：static constexpr + parameter
    static constexpr auto fn2 = [](std::string_view s) {
        std::cout << s << "\n";
    };
    fn2(msg);
}

void process(std::string_view msg) {
    // 寫法 3：non-static + parameter
    const auto fn3 = [](std::string_view s) {
        std::cout << s << "\n";
    };
    fn3(msg);
}

class Handler {
    std::string data;
public:
    // 寫法 0：static + [this]
    void run0() {
        static const auto fn = [this]() {
            std::cout << data << "\n";
        };
        fn();
    }

    // 寫法 1：non-static + [this]
    void run1() {
        const auto fn = [this]() {
            std::cout << data << "\n";
        };
        fn();
    }

    // 寫法 2：static constexpr + string_view parameter
    void run2() {
        static constexpr auto fn = [](std::string_view s) {
            std::cout << s << "\n";
        };
        fn(data);  // string → string_view 隱式轉換
    }

    // 寫法 3：non-static + const string& parameter
    void run3() {
        const auto fn = [](const std::string& s) {
            std::cout << s << "\n";
        };
        fn(data);
    }
};

// 寫法 A：第二個參數用 pointer
void transform(std::string x, std::string* y) {
    // 對 x 和 *y 做複雜操作
}

// 寫法 B：兩個都 pass by value
void transform(std::string x, std::string y) {
    // 對 x 和 y 做複雜操作
}

// 簡化版 std::string 結構（以 GCC libstdc++ 為概念）
class basic_string {
    size_t _size;

    union {
        // 短字串模式：字元直接存在 16 bytes 裡
        char _short_buf[16];       // 15 chars + \0

        // 長字串模式：pointer + capacity
        struct {
            size_t _capacity;
            char*  _ptr;           // → heap
        } _long;
    };
    // sizeof ≈ 8 (size) + 16 (union) = 24~32（因 alignment）
};

string 物件固定 32 bytes（64-bit, GCC）
┌────────┬────────────────────────┐
│  size  │        union           │
│  (8B)  │        (16B)           │
│        ├─ 短字串模式 ───────────┤
│        │  char buf[16]          │  ← 字元直接存這裡
│        ├─ 長字串模式 ───────────┤
│        │  capacity(8B) + ptr(8B)│  ← ptr 指向 heap
└────────┴────────────────────────┘
         ↑ 同一塊記憶體，兩種解讀方式

SSO 閾值（常見 64-bit 實作）：
  GCC libstdc++: ~15 bytes
  Clang libc++:  ~22 bytes
  MSVC:          ~15 bytes

Order Book 結構：
price      quantity
130.000    1          ← 最高 bid
119.000    1
118.000    1
...
111.000    99
110.000    100        ← best bid
------------------------------
109.000    99         ← best ask
108.000    94
...
90.000     3          ← 最低 ask

限制條件：
  - price precision: 18 位小數
  - minimum tick size: 已知（如 0.5）
  - 兩種更新模式：
    Case 1: Snapshot - 一次收到完整 N 層報價，全部覆蓋
    Case 2: Delta    - 只收到有變動的 level
      bid: [ { price: 111, qty: 0 }, { price: 111.5, qty: 60 } ]
      ask: [ { price: 90, qty: 0 }, { price: 108, qty: 100 } ]
      （qty = 0 代表移除該 level）

// Bad: floating point 比較不精確
std::map<double, double> bid;  // ✗

// 0.1 + 0.2 == 0.3 是 false - 這在 order book 裡是致命的
// 兩個 "相同" 價格可能被當成不同 key

// Good: 把價格轉成整數 tick
// 如果 min tick = 0.5, precision = 18
// price 111.5 → tick_index = 111.5 / 0.5 = 223
// 或直接用 fixed-point integer: price * 10^18

using Price = int64_t;  // fixed-point, 或 tick index
using Qty = int64_t;

// bid 要快速找最大 → 降序
std::map<Price, Qty, std::greater<Price>> bid;
// ask 要快速找最小 → 升序（預設）
std::map<Price, Qty> ask;

// Case 1: Snapshot - 全量更新
void applySnapshot(
    std::map<Price, Qty, std::greater<Price>>& bid,
    const std::vector<std::pair<Price, Qty>>& levels
) {
    bid.clear();
    for (const auto& [px, qty] : levels) {
        if (qty > 0) bid[px] = qty;
    }
}

// Case 2: Delta - 增量更新
void applyDelta(
    std::map<Price, Qty, std::greater<Price>>& bid,
    const std::vector<std::pair<Price, Qty>>& deltas
) {
    for (const auto& [px, qty] : deltas) {
        if (qty == 0) {
            bid.erase(px);    // qty=0 代表移除
        } else {
            bid[px] = qty;    // 新增或更新
        }
    }
}