feat: Template sections started

Author: Charliechen114514

drafts/Content-Table-TemplateGuide.md

@@ -14,6 +14,9 @@
 
 **定位：** 从零开始建立完整的模板基础知识体系，适合初学者和需要巩固基础的开发者。
 
+### T1.0
+- 啥是模板，为什么要有模板。模板如何进行学习？
+
 ### T1.1 函数模板
 - 模板参数推导规则
 - 尾随返回类型与返回类型推导

tutorial/核心：现代嵌入式C++教程/Chapter12/0 模板入门概述.md

@@ -0,0 +1,366 @@
+---
+title: "模板入门概述"
+description: "理解C++模板的核心概念与学习路径"
+chapter: 12
+order: 0
+tags:
+  - 模板
+  - 泛型编程
+  - 基础
+difficulty: beginner
+reading_time_minutes: 20
+prerequisites:
+  - "Chapter 2: 零开销抽象"
+  - "Chapter 11: 类型推导基础"
+cpp_standard: [11, 14, 17, 20]
+---
+
+# 嵌入式现代C++教程——模板入门概述
+
+## 引言：为什么需要模板？
+
+想象这样一个场景：你正在为一个嵌入式项目编写通信协议栈，需要处理不同大小的数据包——8位、16位、32位、甚至64位的校验和计算。
+
+用传统C风格，你可能会写出这样的代码：
+
+```cpp
+uint8_t checksum8(const uint8_t* data, size_t len) {
+    uint8_t sum = 0;
+    for (size_t i = 0; i < len; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+
+uint16_t checksum16(const uint16_t* data, size_t len) {
+    uint16_t sum = 0;
+    for (size_t i = 0; i < len; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+
+uint32_t checksum32(const uint32_t* data, size_t len) {
+    uint32_t sum = 0;
+    for (size_t i = 0; i < len; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+```
+
+三个函数，逻辑完全相同，只是类型不同。这不仅写起来烦，维护起来更烦——如果你要修改校验算法（比如加个溢出处理），得改三个地方。
+
+这时候，C++模板就登场了。
+
+------
+
+## 什么是模板？
+
+**模板是C++的泛型编程机制**，它允许你编写与类型无关的代码，让编译器根据具体使用的类型生成对应的函数或类。
+
+用模板重写上面的校验和函数：
+
+```cpp
+template<typename T>
+T checksum(const T* data, size_t len) {
+    T sum = 0;
+    for (size_t i = 0; i < len; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+
+// 使用时
+uint8_t data8[16] = { /* ... */ };
+auto sum8 = checksum<uint8_t>(data8, 16);
+
+uint16_t data16[8] = { /* ... */ };
+auto sum16 = checksum<uint16_t>(data16, 8);
+```
+
+一段代码，适用于所有类型。编译器会根据你调用的方式自动生成对应的函数版本——这个过程叫**模板实例化**。
+
+> 一句话总结：**模板是编译期的代码生成器，它让你写出类型无关的代码，同时保持类型安全。**
+
+------
+
+## 模板的核心价值
+
+### 1. 类型安全 + 代码复用
+
+C语言的宏（Macro）也能实现某种程度的"泛型"，但它是文本替换，没有任何类型检查：
+
+```cpp
+// C风格宏 - 不安全
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+// 问题1：多次求值
+int x = 1;
+int result = MAX(++x, 10);  // x被递增两次！结果可能不是你想要的
+
+// 问题2：类型不匹配
+double d = MAX(3.14, "hello");  // 编译器可能不报错，但行为未定义
+```
+
+模板在编译期进行类型检查，既保证了安全，又实现了复用：
+
+```cpp
+template<typename T>
+T max(const T& a, const T& b) {
+    return a > b ? a : b;
+}
+
+int x = 1;
+int result = max(++x, 10);  // x只递增一次，行为确定
+
+// double d = max(3.14, "hello");  // 编译错误！类型不匹配
+```
+
+### 2. 零开销抽象
+
+现代C++的核心理念之一：**抽象不应该带来运行时开销**。
+
+模板在编译期展开，生成的代码与手写的优化版本没有区别。来看一个例子：
+
+```cpp
+template<typename T, std::size_t N>
+class FixedVector {
+public:
+    T& operator[](std::size_t index) {
+        return data[index];
+    }
+    // ... 其他成员
+private:
+    T data[N];  // 编译期确定大小，栈上分配
+};
+
+FixedVector<int, 8> vec;  // 编译为 int data[8]，没有动态分配
+```
+
+这比`std::vector`更适合嵌入式场景——无需堆分配，大小固定，内存布局完全可预测。
+
+### 3. 编译期计算
+
+模板是C++元编程的基础，允许在编译期完成复杂计算：
+
+```cpp
+template<std::size_t N>
+struct Factorial {
+    static constexpr std::size_t value = N * Factorial<N - 1>::value;
+};
+
+template<>
+struct Factorial<0> {
+    static constexpr std::size_t value = 1;
+};
+
+// 编译期计算
+static_assert(Factorial<5>::value == 120);
+```
+
+这看起来像玩具，但在嵌入式里很有用——比如生成查找表、计算寄存器位掩码等。
+
+------
+
+## 嵌入式开发中的模板
+
+### 模板在嵌入式的独特优势
+
+| 优势 | 说明 | 实际应用 |
+|------|------|----------|
+| 编译期确定 | 无运行时分支 | 寄存器地址映射、协议解析 |
+| 零堆分配 | 避免碎片 | 固定大小容器、对象池 |
+| 类型安全 | 编译期错误检测 | 外设封装、单位系统 |
+| 代码内联 | 减少函数调用开销 | 算法特化、热路径优化 |
+
+### 需要权衡的地方
+
+模板也不是没有代价：
+
+- **代码膨胀**：每个模板实例化都会生成一份代码，Flash占用增加
+- **编译时间**：复杂的模板元编程会显著增加编译时间
+- **错误信息**：模板编译错误信息可能极其晦涩
+- **调试困难**：模板展开后的代码可能与源代码看起来很不一样
+
+实用主义原则：**在关键路径上使用模板优化性能，在普通代码上保持简洁可读。**
+
+------
+
+## 模板的基本类型
+
+C++模板主要分为两大类：
+
+### 1. 函数模板
+
+用于生成类型相关的函数：
+
+```cpp
+template<typename T>
+T add(T a, T b) {
+    return a + b;
+}
+
+// 或用 auto 返回类型推导
+template<typename T>
+auto multiply(T a, T b) -> decltype(a * b) {
+    return a * b;
+}
+```
+
+### 2. 类模板
+
+用于生成类型相关的类：
+
+```cpp
+template<typename T>
+class Stack {
+public:
+    void push(const T& item);
+    T pop();
+    bool empty() const;
+private:
+    std::vector<T> data;
+};
+
+// 使用
+Stack<int> int_stack;
+Stack<std::string> string_stack;
+```
+
+此外还有：
+
+- **成员模板**：类内部的模板函数
+- **变量模板**：C++14引入，用于变量级别的模板
+- **别名模板**：简化复杂类型名
+
+这些将在后续章节详细介绍。
+
+------
+
+## 学习路线建议
+
+模板学习曲线较陡，但遵循正确的路径可以事半功倍：
+
+### 第一阶段：掌握基础（1-2周）
+
+1. **理解模板实例化机制**：编译器如何从模板生成具体代码
+2. **函数模板**：参数推导、返回类型推导
+3. **类模板**：基本声明、成员定义、特化
+4. **实用技巧**：`auto`/`decltype`与模板的结合
+
+### 第二阶段：深入类型系统（2-3周）
+
+1. **类型萃取**（Type Traits）：`<type_traits>`库的使用
+2. **SFINAE**：理解"替换失败并非错误"
+3. **`std::enable_if`**：条件编译的技术
+4. **标签分发**（Tag Dispatching）：编译期算法选择
+
+### 第三阶段：现代模板技术（3-4周）
+
+1. **`constexpr`**：编译期计算
+2. **可变参数模板**：处理任意数量参数
+3. **折叠表达式**：简化参数包操作
+4. **`if constexpr`**：编译期条件分支
+
+### 第四阶段：C++20 Concepts（1-2周）
+
+1. **Concepts定义**：约束模板参数
+2. **Requires表达式**：编写清晰的概念
+3. **缩写函数模板**：更简洁的语法
+4. **Concept重载**：更智能的重载决议
+
+### 学习建议
+
+- **动手实践**：每学一个概念就写代码验证，看生成的汇编
+- **阅读标准库**：`std::vector`、`std::algorithm`是最佳教材
+- **逐步深入**：不要一开始就陷入复杂的元编程
+- **实用主义**：在嵌入式中，能用简单方案解决的不要强行模板化
+
+------
+
+## 常见误区澄清
+
+### 误区1："模板会让代码变慢"
+
+**事实**：正确使用的模板代码与手写代码性能完全相同。编译器会对模板代码进行同样的优化。内联、常量传播、死代码消除等优化对模板代码完全有效。
+
+### 误区2："模板只适合库开发者"
+
+**事实**：模板是C++基础特性，理解它有助于更好地使用标准库、编写类型安全的代码。嵌入式开发者经常使用的`std::array`、`std::tuple`等都是模板。
+
+### 误区3："模板代码体积一定会膨胀"
+
+**事实**：膨胀程度取决于使用方式。通过共享基类、`extern template`显式实例化等技术可以有效控制。很多情况下，模板带来的编译期优化反而能减小最终代码。
+
+### 误区4："必须精通所有模板技巧"
+
+**事实**：掌握基础就足够应对80%的场景。复杂的元编程技巧只在特定场景下需要。
+
+------
+
+## 实战：第一个有用的模板
+
+让我们用一个实用的例子结束本章——一个类型安全的位掩码工具：
+
+```cpp
+template<typename RegType, RegType Bit>
+struct BitMask {
+    static constexpr RegType mask = static_cast<RegType>(1) << Bit;
+
+    // 设置位
+    static inline RegType set(RegType reg) {
+        return reg | mask;
+    }
+
+    // 清除位
+    static inline RegType clear(RegType reg) {
+        return reg & ~mask;
+    }
+
+    // 切换位
+    static inline RegType toggle(RegType reg) {
+        return reg ^ mask;
+    }
+
+    // 测试位
+    static inline bool is_set(RegType reg) {
+        return (reg & mask) != 0;
+    }
+};
+
+// 使用场景：GPIO配置
+using Pin5 = BitMask<uint32_t, 5>;
+
+uint32_t gpio_mode = 0;
+gpio_mode = Pin5::set(gpio_mode);    // 设置第5位
+if (Pin5::is_set(gpio_mode)) {
+    // 第5位已设置
+}
+```
+
+这段代码：
+
+- **类型安全**：编译期保证位索引有效
+- **零开销**：所有函数都会内联为单条指令
+- **自文档**：`Pin5::set()`比`gpio_mode |= (1 << 5)`更清晰
+
+------
+
+## 小结
+
+模板是现代C++的核心特性，它：
+
+1. **提供类型安全的泛型编程**：避免宏的不安全性
+2. **实现零开销抽象**：编译期生成，与手写代码性能相同
+3. **支持编译期计算**：将运行时工作前置到编译期
+4. **是现代C++基础设施**：标准库、STL都建立在模板之上
+
+对于嵌入式开发者，模板特别适合：
+
+- 编译期确定的配置
+- 类型安全的外设封装
+- 零堆分配的数据结构
+- 性能关键的算法特化
+
+**下一章**，我们将深入探讨**函数模板**，学习模板参数推导、返回类型推导、重载决议等核心机制，并实现一个通用的`min/max/clamp`函数族。