1
// auto 基础用法
2
auto x = 42;            // int
3
auto y = 3.14;          // double
4
auto s = std::string("hello");  // std::string
5
auto it = map.begin();  // std::map<K,V>::iterator（省去冗长类型名）
6

7
// auto 的推导规则（和模板参数推导一样）：
8
// 1. 去掉引用
9
// 2. 去掉顶层 const
10
int val = 42;
11
const int& ref = val;
12
auto a = ref;           // int（去掉 const 和 &）
13
auto& b = ref;          // const int&（保留 const，因为 & 保持引用）
14
const auto& c = val;    // const int&
15

16
// ⚠️ auto 陷阱
17
auto x1 = {1, 2, 3};    // std::initializer_list<int>！不是 vector
18
auto x2{42};             // C++17: int（C++11/14: initializer_list<int>）
19
auto x3 = {42};          // std::initializer_list<int>（所有版本）

1
int x = 42;
2
int& ref = x;
3

4
// decltype 保留表达式的完整类型
5
decltype(x)   a = 10;     // int
6
decltype(ref) b = x;      // int&（保留引用）
7
decltype((x)) c = x;      // int&！（(x) 是左值表达式）
8
// ↑ 面试高频坑点：decltype(x) 和 decltype((x)) 结果不同
9

10
// decltype(auto)：按 decltype 规则推导
11
decltype(auto) d = x;      // int（decltype(x) = int）
12
decltype(auto) e = ref;    // int&（decltype(ref) = int&）
13
decltype(auto) f = (x);    // int&！（decltype((x)) = int&）
14
// ↑ 永远不要 decltype(auto) f = (local_var); 会返回悬垂引用
15

16
// 实际应用：完美返回类型
17
template <typename F, typename... Args>
18
decltype(auto) call(F&& f, Args&&... args) {
19
    return std::forward<F>(f)(std::forward<Args>(args)...);
20
    // 如果 f 返回引用，这里也返回引用（不会意外拷贝）
21
}

1
// 基本语法
2
// [capture](params) -> return_type { body }
3

4
// 捕获方式
5
int a = 10, b = 20;
6

7
auto f1 = [a, b]()    { return a + b; };   // 值捕获（拷贝）
8
auto f2 = [&a, &b]()  { a += b; };         // 引用捕获
9
auto f3 = [=]()        { return a + b; };   // 全部值捕获
10
auto f4 = [&]()        { a += b; };         // 全部引用捕获
11
auto f5 = [=, &a]()    { a += b; };         // 混合：a 引用，其余值捕获
12
auto f6 = [&, a]()     { return a + b; };   // 混合：a 值捕获，其余引用
13

14
// C++14：泛型 Lambda（auto 参数）
15
auto add = [](auto a, auto b) { return a + b; };
16
add(3, 5);          // int
17
add(3.14, 2.71);    // double
18

19
// C++14：初始化捕获（移动捕获）
20
auto ptr = std::make_unique<int>(42);
21
auto f7 = [p = std::move(ptr)]() {
22
    return *p;  // 把 unique_ptr 移入 Lambda
23
};
24

25
// C++17：*this 捕获（拷贝整个对象）
26
class Widget {
27
    int _value = 42;
28
public:
29
    auto getAction() {
30
        // [this] 捕获 this 指针（如果对象被销毁 → 悬垂）
31
        // [*this] 拷贝整个对象（安全，但有开销）
32
        return [*this]() { return _value; };
33
    }
34
};
35

36
// C++20：模板 Lambda
37
auto typed_add = []<typename T>(T a, T b) { return a + b; };
38

39
// 立即调用 Lambda (IIFE)
40
const auto config = []() {
41
    Config c;
42
    c.width = 1920;
43
    c.height = 1080;
44
    c.fullscreen = true;
45
    return c;
46
}();  // 注意末尾的 ()

1
// === nullptr ===
2
// NULL 是 0，在重载决议中可能被当作 int
3
void f(int* p);
4
void f(int n);
5
f(NULL);     // ❌ 歧义！NULL = 0，可匹配两者
6
f(nullptr);  // ✅ 明确是空指针
7

8
// === enum class ===
9
// 传统 enum 的问题：全局作用域 + 隐式转换 int
10
enum Color { Red, Green, Blue };  // Red 是全局的
11
enum Fruit { Apple, Orange };
12
// int x = Red + Apple;  // ✅ 编译通过（但语义荒谬）
13

14
// enum class：类型安全
15
enum class Direction { Up, Down, Left, Right };
16
// int x = Direction::Up;           // ❌ 不能隐式转 int
17
int x = static_cast<int>(Direction::Up);  // ✅ 必须显式
18

19
// C++17：可以指定底层类型
20
enum class InputKey : uint8_t {
21
    W = 0, A, S, D, Space, Shift
22
};
23

24
// === 范围 for ===
25
std::vector<int> v = {1, 2, 3, 4, 5};
26
for (auto& x : v) { x *= 2; }     // 引用修改
27
for (const auto& x : v) { ... }    // const 引用读取（推荐）
28

29
// 展开等价于：
30
// for (auto __begin = v.begin(), __end = v.end(); __begin != __end; ++__begin) {
31
//     auto& x = *__begin;
32
// }

1
#include <optional>
2

3
// 表示"可能没有值"——替代裸指针/魔法值
4
std::optional<int> findPlayer(const std::string& name) {
5
    if (auto it = players.find(name); it != players.end()) {
6
        return it->second.id;
7
    }
8
    return std::nullopt;  // 没找到
9
}
10

11
// 使用
12
auto result = findPlayer("Alice");
13
if (result) {
14
    std::cout << "ID: " << *result << "\n";     // 解引用
15
    std::cout << "ID: " << result.value() << "\n";  // .value() 无值时抛异常
16
}
17

18
// 提供默认值
19
int id = result.value_or(-1);  // 没有则返回 -1
20

21
// ⚠️ 不适用于：大对象（optional 在栈上存完整对象）、高频调用路径

1
#include <variant>
2

3
// 类型安全的 union —— 取代 C 的 union + tag
4
using GameEvent = std::variant<
5
    MouseClickEvent,
6
    KeyPressEvent,
7
    WindowResizeEvent
8
>;
9

10
GameEvent event = KeyPressEvent{KeyCode::W, true};
11

12
// 访问方式 1：std::get（抛异常版）
13
auto& key = std::get<KeyPressEvent>(event);  // 类型不对 → 抛 bad_variant_access
14

15
// 访问方式 2：std::get_if（安全版）
16
if (auto* click = std::get_if<MouseClickEvent>(&event)) {
17
    handleClick(click->x, click->y);
18
}
19

20
// 访问方式 3：std::visit（最推荐，用 visitor 模式）
21
std::visit([](auto&& arg) {
22
    using T = std::decay_t<decltype(arg)>;
23
    if constexpr (std::is_same_v<T, MouseClickEvent>) {
24
        handleClick(arg.x, arg.y);
25
    } else if constexpr (std::is_same_v<T, KeyPressEvent>) {
26
        handleKey(arg.key, arg.pressed);
27
    } else if constexpr (std::is_same_v<T, WindowResizeEvent>) {
28
        handleResize(arg.width, arg.height);
29
    }
30
}, event);
31

32
// overloaded 技巧（C++17 惯用法）
33
template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
34
template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
35

36
std::visit(overloaded{
37
    [](MouseClickEvent& e)   { handleClick(e.x, e.y); },
38
    [](KeyPressEvent& e)     { handleKey(e.key, e.pressed); },
39
    [](WindowResizeEvent& e) { handleResize(e.width, e.height); },
40
}, event);

1
#include <string_view>
2

3
// string_view = 只读的字符串引用（指针 + 长度），零拷贝
4
void log(std::string_view msg) {
5
    std::cout << "[LOG] " << msg << "\n";
6
}
7

8
// 接受任何字符串类型，不拷贝
9
log("hello");                    // const char* → string_view（零拷贝）
10
log(std::string("hello"));      // string → string_view（零拷贝）
11
log(some_string.substr(0, 5));   // 无需创建子串的 string
12

13
// ⚠️ 生命周期陷阱
14
std::string_view dangerous() {
15
    std::string local = "hello";
16
    return local;  // ❌ local 销毁后 string_view 悬垂！
17
}
18
// string_view 不拥有数据，必须确保底层字符串存活
19

20
// 性能对比
21
void f1(const std::string& s);   // 传 "hello" → 构造临时 string（堆分配）
22
void f2(std::string_view sv);     // 传 "hello" → 只设指针和长度（零开销）

1
// if constexpr（编译期分支，详见 Ch5）
2
template <typename T>
3
auto process(const T& val) {
4
    if constexpr (std::is_integral_v<T>) {
5
        return val * 2;
6
    } else {
7
        return val;
8
    }
9
}
10

11
// constexpr 函数：编译期 or 运行期都能执行
12
constexpr int factorial(int n) {
13
    int result = 1;
14
    for (int i = 2; i <= n; ++i) result *= i;
15
    return result;
16
}
17

18
constexpr int f5 = factorial(5);    // 编译期计算 → 120
19
int n = getUserInput();
20
int fn = factorial(n);              // 运行期计算
21

22
// C++17：constexpr if + constexpr Lambda
23
auto constexpr_lambda = [](int n) constexpr { return n * n; };
24
static_assert(constexpr_lambda(5) == 25);

1
#include <ranges>
2
#include <algorithm>
3

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

6
// 传统写法
7
std::sort(v.begin(), v.end());
8
auto it = std::find_if(v.begin(), v.end(), [](int x) { return x > 5; });
9

10
// Ranges 写法：管道风格
11
auto result = v
12
    | std::views::filter([](int x) { return x % 2 == 0; })  // 筛选偶数
13
    | std::views::transform([](int x) { return x * x; })     // 平方
14
    | std::views::take(3);                                     // 取前 3 个
15

16
for (int x : result) {
17
    std::cout << x << " ";  // 4 16 64
18
}
19
// 注意：views 是惰性求值，不创建中间容器！

1
#include <coroutine>
2

3
// 协程 = 可暂停和恢复的函数
4
// 关键字：co_await（等待）、co_yield（产出值）、co_return（返回）
5

6
// 简化的 Generator（产出序列值）
7
template <typename T>
8
struct Generator {
9
    struct promise_type {
10
        T current_value;
11
        Generator get_return_object() {
12
            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
13
        }
14
        std::suspend_always initial_suspend() { return {}; }
15
        std::suspend_always final_suspend() noexcept { return {}; }
16
        std::suspend_always yield_value(T value) {
17
            current_value = value;
18
            return {};
19
        }
20
        void return_void() {}
21
        void unhandled_exception() { std::terminate(); }
22
    };
23

24
    std::coroutine_handle<promise_type> handle;
25

26
    bool next() {
27
        handle.resume();
28
        return !handle.done();
29
    }
30
    T value() const { return handle.promise().current_value; }
31

32
    ~Generator() { if (handle) handle.destroy(); }
33
};
34

35
// 使用协程生成斐波那契数列
36
Generator<int> fibonacci() {
37
    int a = 0, b = 1;
38
    while (true) {
39
        co_yield a;
40
        auto next = a + b;
41
        a = b;
42
        b = next;
43
    }
44
}
45

46
auto gen = fibonacci();
47
for (int i = 0; i < 10 && gen.next(); ++i) {
48
    std::cout << gen.value() << " ";  // 0 1 1 2 3 5 8 13 21 34
49
}

1
#include <compare>
2

3
struct Vec2 {
4
    float x, y;
5

6
    // 一行搞定所有比较运算符（==, !=, <, >, <=, >=）
7
    auto operator<=>(const Vec2&) const = default;
8
};
9

10
Vec2 a{1, 2}, b{3, 4};
11
bool eq = (a == b);   // false
12
bool lt = (a < b);    // true（先比 x，再比 y）
13

14
// 自定义排序逻辑
15
struct Score {
16
    int points;
17
    float time;
18

19
    std::strong_ordering operator<=>(const Score& other) const {
20
        // 分数高的排前面，相同分数时时间短的排前面
21
        if (auto cmp = other.points <=> points; cmp != 0) return cmp;
22
        return time <=> other.time;  // 注意：不是 other.time
23
    }
24
    bool operator==(const Score&) const = default;
25
};

1
#include <span>
2

3
// span = 连续内存的非拥有视图（类似 string_view 对 string）
4
void processVertices(std::span<const float> vertices) {
5
    for (float v : vertices) { /* ... */ }
6
}
7

8
// 接受任何连续容器，零拷贝
9
std::vector<float> vec = {1, 2, 3, 4};
10
float arr[] = {5, 6, 7, 8};
11
std::array<float, 4> stdarr = {9, 10, 11, 12};
12

13
processVertices(vec);       // ✅ vector
14
processVertices(arr);       // ✅ C 数组
15
processVertices(stdarr);    // ✅ std::array
16
processVertices({vec.data() + 1, 2});  // ✅ 子范围
17

18
// 游戏中特别有用：GPU 缓冲区上传
19
void uploadToGPU(std::span<const float> data) {
20
    glBufferData(GL_ARRAY_BUFFER, data.size_bytes(), data.data(), GL_STATIC_DRAW);
21
}

1
// === 陷阱 1：auto 推导 initializer_list ===
2
auto x = {1, 2, 3};   // initializer_list<int>，不是 vector！
3

4
// === 陷阱 2：Lambda 捕获悬垂引用 ===
5
auto makeLambda() {
6
    int local = 42;
7
    return [&local]() { return local; };  // ❌ local 已销毁
8
    // ✅ return [local]() { return local; };  // 值捕获
9
}
10

11
// === 陷阱 3：optional 的 value() ===
12
std::optional<int> opt;
13
// int v = opt.value();  // 💥 抛 std::bad_optional_access
14
int v = opt.value_or(0); // ✅ 安全
15

16
// === 陷阱 4：string_view 的生命周期 ===
17
std::string_view sv;
18
{
19
    std::string s = "hello";
20
    sv = s;   // sv 指向 s 的数据
21
}
22
// sv 悬垂了！s 已销毁，sv 指向已释放的内存
23

24
// === 陷阱 5：decltype((x)) 意外返回引用 ===
25
int x = 42;
26
decltype(x) a;    // int
27
decltype((x)) b = x;  // int&（加了括号变成表达式）

1
struct HitResult {
2
    Vec3 point;
3
    Vec3 normal;
4
    float distance;
5
    Entity* entity;
6
};
7

8
// optional 表示"可能没打中"
9
std::optional<HitResult> raycast(const Ray& ray, float maxDist) {
10
    for (auto& collider : colliders) {
11
        if (auto hit = collider.intersect(ray, maxDist)) {
12
            return hit;
13
        }
14
    }
15
    return std::nullopt;  // 没打中
16
}
17

18
// 使用
19
if (auto hit = raycast(playerRay, 100.f)) {
20
    // 打中了
21
    spawnImpactEffect(hit->point, hit->normal);
22
    hit->entity->takeDamage(weapon.damage);
23
} else {
24
    // 没打中
25
}

1
// 类型安全的事件数据
2
struct PlayerMoveEvent  { Vec3 position; Vec3 direction; };
3
struct PlayerDamageEvent { float damage; DamageType type; Entity* source; };
4
struct ItemPickupEvent  { ItemId item; int quantity; };
5

6
using GameEvent = std::variant<PlayerMoveEvent, PlayerDamageEvent, ItemPickupEvent>;
7

8
class EventBus {
9
    std::vector<std::function<void(const GameEvent&)>> _listeners;
10

11
public:
12
    void subscribe(std::function<void(const GameEvent&)> listener) {
13
        _listeners.push_back(std::move(listener));
14
    }
15

16
    void publish(const GameEvent& event) {
17
        for (auto& listener : _listeners) {
18
            listener(event);
19
        }
20
    }
21
};
22

23
// 订阅
24
bus.subscribe([](const GameEvent& event) {
25
    std::visit(overloaded{
26
        [](const PlayerDamageEvent& e) {
27
            showDamageNumber(e.damage);
28
            playHitSound(e.type);
29
        },
30
        [](const ItemPickupEvent& e) {
31
            showPickupNotification(e.item, e.quantity);
32
        },
33
        [](auto&&) { /* 忽略其他事件 */ }
34
    }, event);
35
});

1
class Logger {
2
public:
3
    // string_view：接受任何字符串，零拷贝
4
    void log(std::string_view level, std::string_view msg,
5
             std::string_view file, int line) {
6
        std::cout << "[" << level << "] " << msg
7
                  << " (" << file << ":" << line << ")\n";
8
    }
9
};
10

11
// 宏利用 __FILE__ 和 __LINE__
12
#define LOG_INFO(msg)  logger.log("INFO",  msg, __FILE__, __LINE__)
13
#define LOG_WARN(msg)  logger.log("WARN",  msg, __FILE__, __LINE__)
14
#define LOG_ERROR(msg) logger.log("ERROR", msg, __FILE__, __LINE__)
15

16
// 配置文件解析：用 string_view 避免大量子串拷贝
17
void parseConfig(std::string_view content) {
18
    while (!content.empty()) {
19
        auto newline = content.find('\n');
20
        auto line = content.substr(0, newline);
21

22
        auto eq = line.find('=');
23
        if (eq != std::string_view::npos) {
24
            auto key = line.substr(0, eq);
25
            auto val = line.substr(eq + 1);
26
            // key 和 val 都是 string_view → 零拷贝！
27
            config[std::string(key)] = std::string(val);
28
        }
29

30
        content = (newline == std::string_view::npos)
31
            ? "" : content.substr(newline + 1);
32
    }
33
}

1
// 协程让异步逻辑写起来像同步代码
2
Task<void> dialogueSequence(DialogueUI& ui) {
3
    ui.showText("Hero: 你好，老爷爷！");
4
    co_await ui.waitForClick();    // 暂停，等待玩家点击
5

6
    ui.showText("NPC: 年轻人，前方有龙！");
7
    co_await ui.waitForClick();
8

9
    auto choice = co_await ui.showChoice({
10
        "去打龙",
11
        "我怕，不去了"
12
    });
13

14
    if (choice == 0) {
15
        ui.showText("NPC: 勇者，拿着这把剑！");
16
        player.addItem(Items::DragonSlayer);
17
    } else {
18
        ui.showText("NPC: 那你回家吧...");
19
    }
20
    co_await ui.waitForClick();
21
    ui.close();
22
}
23

24
// 传统回调写法（回调地狱）：
25
// ui.showText("...", [&]() {
26
//     ui.showText("...", [&]() {
27
//         ui.showChoice({...}, [&](int choice) {
28
//             if (choice == 0) { ... } else { ... }
29
//         });
30
//     });
31
// });

1
// 编译期计算查找表（零运行时开销）
2
constexpr std::array<float, 360> buildSinTable() {
3
    std::array<float, 360> table{};
4
    for (int i = 0; i < 360; ++i) {
5
        table[i] = static_cast<float>(
6
            std::sin(i * 3.14159265358979 / 180.0)
7
        );
8
    }
9
    return table;
10
}
11

12
constexpr auto SIN_TABLE = buildSinTable();
13
// SIN_TABLE 在编译期就算好了，运行时直接查表
14

15
// 编译期 hash（字符串作为 switch case）
16
constexpr uint32_t hash(std::string_view sv) {
17
    uint32_t hash = 2166136261u;
18
    for (char c : sv) {
19
        hash ^= static_cast<uint32_t>(c);
20
        hash *= 16777619u;
21
    }
22
    return hash;
23
}
24

25
void handleCommand(std::string_view cmd) {
26
    switch (hash(cmd)) {
27
        case hash("attack"): doAttack(); break;
28
        case hash("defend"): doDefend(); break;
29
        case hash("heal"):   doHeal();   break;
30
        default: std::cout << "Unknown command\n";
31
    }
32
    // 编译期计算 hash 值 → switch 直接跳转，零开销
33
}