video(cpp11/00): manim animation for auto/decltype (#53)

* video(cpp11/00): add manim animation for auto/decltype

Manim Community v0.18.1 scene mirroring the existing videos/cpp11/*
framework (MovingCameraScene + d2x mcpp_video_start/end, DHighlight,
create_code_helper). Six scenes following the chapter:
declaration, expression deduction, complex types (iterator),
trailing-return + decltype, const/reference stripping, and the
decltype parentheses pitfall.

Run: uv run --with "manim==0.18.1" manim -pql videos/cpp11/00-auto-and-decltype.py

* docs(cpp11/00): sync bilingual docs + add animation video link

- Sync en doc to zh: iterator example (v.insert) and const/reference
  stripping example now match the zh version's code
- Add Bilibili animation link (BV1EzJs6HEf7) alongside the existing
  explanation video in both book docs and videos/README.md
- Add render.sh launcher and refine the manim animation script

* docs(cpp11/00): correct video labels — 视频解读=BV1EzJs6HEf7, 练习讲解=BV1xkdYYUEyH

Author: Sunrisepeak

book/en/src/cpp11/00-auto-and-decltype.md

@@ -12,7 +12,7 @@ auto and decltype are powerful **type deduction** tools introduced in C++11. The
 
 | Book | Video | Code | X |
 | --- | --- | --- | --- |
-| [cppreference-auto](https://en.cppreference.com/w/cpp/language/auto) / [cppreference-decltype](https://en.cppreference.com/w/cpp/language/decltype) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/en/src/cpp11/00-auto-and-decltype.md) | [Video Explanation](https://www.bilibili.com/video/BV1xkdYYUEyH) | [Practice Code](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp) |  |
+| [cppreference-auto](https://en.cppreference.com/w/cpp/language/auto) / [cppreference-decltype](https://en.cppreference.com/w/cpp/language/decltype) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/en/src/cpp11/00-auto-and-decltype.md) | [Video Explanation](https://www.bilibili.com/video/BV1EzJs6HEf7) / [Exercise Walkthrough](https://www.bilibili.com/video/BV1xkdYYUEyH) | [Practice Code](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp) |  |
 
 
 **Why were they introduced?**
@@ -61,10 +61,14 @@ decltype(2 + 'a') c2 = 2 + 'a';
 ```cpp
 std::vector<int> v = {1, 2, 3};
 
+// std::vector<int>::iterator it = v.begin();
 auto it = v.begin(); // Automatically deduce iterator type
 // decltype(v.begin()) it = v.begin();
 for (; it != v.end(); ++it) {
-    std::cout << *it << " ";
+    if (*it == 2) {
+        v.insert(it, 0);
+        break;
+    }
 }
 ```
 
@@ -137,41 +141,42 @@ int main() {
 
 ## II. Real-World Case - auto/decltype in the STL
 
-> The examples above illustrate syntax; the real value of auto/decltype shows up most directly in the standard library's own implementation. Below we use the in-repo [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) as the source ([`msvc-stl/stl/inc/xutility`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/xutility#L2200-L2235)); `_EXPORT_STD` / `_NODISCARD` / `_CONSTEXPR17` / `_STD` are internal library macros — ignore them when reading.
+> The examples above illustrate syntax; the practical value of auto/decltype is demonstrated most directly in the standard library's own implementation. The following picks two common pieces of code from the in-repo [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) to demonstrate `auto` and `decltype` respectively; `_STD` and the like are internal library macros and qualifiers — focus on the `auto` / `decltype` when reading.
 
-### Trailing return type + decltype: std::begin / std::end
+### auto deduces iterator and element types: traversing a container
 
-`std::begin` / `std::end` (added in C++11) must adapt to any container; their return type depends entirely on `_Cont.begin()` and cannot be written ahead of time, so they "borrow" it via `auto ... -> decltype(...)`
+Traversing a container is the most common scenario for `auto`. Below is a traversal from path normalization in `<filesystem>`: `auto _Pos` deduces the iterator type, and `const auto _Elem` deduces the element type obtained by dereferencing — the very same form as `auto it = v.begin()` from "Complex type deduction - iterators" in `## I`.
 
 ```cpp
-// MSVC STL · msvc-stl/stl/inc/xutility (abridged)
-_EXPORT_STD template <class _Container>
-_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) -> decltype(_Cont.begin()) {
-    return _Cont.begin();
-}
-
-_EXPORT_STD template <class _Container>
-_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
-    return _Cont.end();
-}
+// MSVC STL · msvc-stl/stl/inc/filesystem (abridged, original indentation kept)
+            auto _New_end = _Vec.begin();
+            for (auto _Pos = _Vec.begin(); _Pos != _Vec.end();) {
+                const auto _Elem = *_Pos++;
+                // ...(decide whether to write _Elem back to _New_end; omitted)
+            }
 ```
 
-This is exactly the trailing-return form from the "Function Return Type Deduction" section, living inside the standard library itself: `auto` as the placeholder + `decltype(_Cont.begin())` precisely deducing the differing iterator types of `vector<int>`, `list<T>`, and so on.
+`_Vec` is the container of path components; both its iterator type and its element type are left to `auto`, with no need to spell out the concrete types.
 
-### Reusing another function's return type with decltype: std::cbegin / std::cend
+### decltype takes the type of a variable: the binary search in std::lower_bound
 
-Going further, `std::cbegin` simply reuses `begin`'s return type via `decltype(_STD begin(_Cont))` — it doesn't care what that type is, only that it "matches what begin returns"
+The most direct use of `decltype` is "take the type of a variable or expression". In the standard library's binary search `std::lower_bound`, `auto` first deduces the range length `_Count`, then `decltype(_Count)` denotes "the same type as `_Count`" to convert `_Count / 2` back to that type:
 
 ```cpp
-// MSVC STL · msvc-stl/stl/inc/xutility (abridged)
-_EXPORT_STD template <class _Container>
-_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
-    -> decltype(_STD begin(_Cont)) {
-    return _STD begin(_Cont);
-}
+// MSVC STL · msvc-stl/stl/inc/xutility (abridged) —— std::lower_bound
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
+        // ...(compare at _UMid, narrow the range; omitted)
+    }
 ```
 
-> Takeaway: when a type "is decided by template parameters and simply cannot be written by hand", the standard library reaches for exactly the auto + decltype toolkit taught in this chapter — one of the core motivations for introducing them in C++11.
+This is the same use as `decltype(b) b2` from "Declaration and definition" in `## I`: `decltype(_Count)` is simply "the type of `_Count`". `auto` deduces the type, and `decltype` reuses that same type elsewhere.
+
+> Takeaway: traversing a container, reusing the type of some variable — these everyday forms are, inside the standard library, exactly the auto + decltype toolkit taught in this chapter. This is one of the core motivations for introducing them in C++11.
 
 ## III. Important Notes
 
@@ -180,17 +185,21 @@ _NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD
 > auto deduction **strips top-level const and references**; to keep them you must write `const auto&` / `auto&` explicitly, whereas decltype preserves the declared type exactly
 
 ```cpp
-const int ci = 1;
-int n = 2;
-int& ri = n;
+int a = 1;
+int &b = a;
+const int c = 1;
+const int &d = c;
 
-auto a = ci;          // int — top-level const stripped
-auto b = ri;          // int — reference stripped (b is an independent copy of n)
+auto a1 = a; // int
+auto b1 = b; // int
+auto c1 = c; // int
+auto d1 = d; // int
 
-const auto& r1 = ci;  // const int& — preserved via const auto&
-auto&& r2 = ci;       // const int& — forwarding reference keeps it
+const auto c2 = c;  // const int
+const auto &d2 = d; // const int &
 
-decltype(ci) d = ci;  // const int — decltype preserves exactly
+decltype(c) c3 = c; // const int
+decltype(d) d3 = d; // const int &
 ```
 
 This is also why `auto a = obj.a;` in "Class/Struct Member Type Deduction" yields `int` rather than `const int` — auto stripped the top-level const.

book/src/cpp11/00-auto-and-decltype.md

@@ -12,7 +12,7 @@ auto 和 decltype 是C++11引入的强有力的**类型自动推导**工具. 不
 
 | Book | Video | Code | X |
 | --- | --- | --- | --- |
-| [cppreference-auto](https://en.cppreference.com/w/cpp/language/auto) / [cppreference-decltype](https://en.cppreference.com/w/cpp/language/decltype) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md) | [视频解读](https://www.bilibili.com/video/BV1xkdYYUEyH) | [练习代码](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp) |  |
+| [cppreference-auto](https://en.cppreference.com/w/cpp/language/auto) / [cppreference-decltype](https://en.cppreference.com/w/cpp/language/decltype) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md) | [视频解读](https://www.bilibili.com/video/BV1EzJs6HEf7) / [练习讲解](https://www.bilibili.com/video/BV1xkdYYUEyH) | [练习代码](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp) |  |
 
 
 **为什么引入?**
@@ -61,10 +61,14 @@ decltype(2 + 'a') c2 = 2 + 'a';
 ```cpp
 std::vector<int> v = {1, 2, 3};
 
+// std::vector<int>::iterator it = v.begin();
 auto it = v.begin(); // 自动推导it类型
 // decltype(v.begin()) it = v.begin();
 for (; it != v.end(); ++it) {
-    std::cout << *it << " ";
+    if (*it == 2) {
+        v.insert(it, 0);
+        break;
+    }
 }
 ```
 
@@ -137,41 +141,42 @@ int main() {
 
 ## 二、真实案例 - STL 中的 auto/decltype
 
-> 前面的例子是为了讲语法, 而 auto/decltype 真正的价值, 在标准库自己的实现里体现得最直接。下面以仓库内置的 [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) 为例 (源码: [`msvc-stl/stl/inc/xutility`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/xutility#L2200-L2235)); `_EXPORT_STD` / `_NODISCARD` / `_CONSTEXPR17` / `_STD` 是库内部宏, 阅读时可忽略
+> 前述示例用于讲解语法, 而 auto/decltype 的实际价值, 在标准库自身的实现中体现得最为直接。下面从仓库内置的 [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) 中选取两段常见代码, 分别演示 `auto` 与 `decltype`; `_STD` 等是库内部的宏与限定写法, 阅读时关注 `auto` / `decltype` 即可
 
-### 后置返回类型 + decltype:std::begin / std::end
+### auto 推导迭代器与元素类型:遍历容器
 
-`std::begin` / `std::end` (C++11 新增) 要适配任意容器, 返回类型完全取决于 `_Cont.begin()`, 没法提前写死, 于是直接用 `auto ... -> decltype(...)` 把返回类型"借"过来
+遍历容器是 `auto` 最常见的场景。下面是 `<filesystem>` 规范化路径时的一段遍历:`auto _Pos` 推导出迭代器类型, `const auto _Elem` 推导出解引用后的元素类型 —— 与 `## 一`「复杂类型推导 - 迭代器」里的 `auto it = v.begin()` 完全是同一种写法
 
 ```cpp
-// MSVC STL · msvc-stl/stl/inc/xutility (有删节)
-_EXPORT_STD template <class _Container>
-_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) -> decltype(_Cont.begin()) {
-    return _Cont.begin();
-}
-
-_EXPORT_STD template <class _Container>
-_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
-    return _Cont.end();
-}
+// MSVC STL · msvc-stl/stl/inc/filesystem (有删节, 缩进保留源码层级)
+            auto _New_end = _Vec.begin();
+            for (auto _Pos = _Vec.begin(); _Pos != _Vec.end();) {
+                const auto _Elem = *_Pos++;
+                // ...（根据 _Elem 决定是否写回 _New_end, 略）
+            }
 ```
 
-这正是本章「函数返回值类型推导」一节讲的后置返回写法在标准库里的真身: `auto` 占位 + `decltype(_Cont.begin())` 精确推导出 `vector<int>::iterator`、`list<T>::iterator` 等各不相同的迭代器类型
+`_Vec` 是路径分量的容器, 它的迭代器类型与元素类型都交给 `auto` 推导, 无需写出具体类型
 
-### 用 decltype 复用另一个函数的返回类型:std::cbegin / std::cend
+### decltype 取变量的类型:std::lower_bound 的二分查找
 
-更进一步, `std::cbegin` 干脆用 `decltype(_STD begin(_Cont))` 直接复用了 `begin` 的返回类型 —— 不必关心它到底是什么, 只要"和 begin 返回的一样"就行
+`decltype` 最直接的用法就是"取某个变量或表达式的类型"。标准库的二分查找 `std::lower_bound` 里, 先用 `auto` 推导出区间长度 `_Count`, 再用 `decltype(_Count)` 表示"与 `_Count` 相同的类型", 把 `_Count / 2` 转换回该类型:
 
 ```cpp
-// MSVC STL · msvc-stl/stl/inc/xutility (有删节)
-_EXPORT_STD template <class _Container>
-_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
-    -> decltype(_STD begin(_Cont)) {
-    return _STD begin(_Cont);
-}
+// MSVC STL · msvc-stl/stl/inc/xutility (有删节) —— std::lower_bound
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
+        // ...（在 _UMid 处比较, 缩小区间, 略）
+    }
 ```
 
-> 小结: 面对"类型由模板参数决定、人手根本写不出来"的场景, 标准库用的正是本章这套 auto + decltype 工具。这也是 C++11 当初引入它们的核心动机之一
+这正是 `## 一`「声明定义」中 `decltype(b) b2` 的同款用法: `decltype(_Count)` 就是"`_Count` 的类型"。`auto` 负责把类型推导出来, `decltype` 负责在别处复用同一个类型
+
+> 小结: 遍历容器、复用某个变量的类型 —— 这些日常写法在标准库内部用的正是本章这套 auto + decltype 工具。这也是 C++11 引入二者的核心动机之一
 
 ## 三、注意事项
 
@@ -180,17 +185,21 @@ _NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD
 > auto 推导会**剥离顶层 const 和引用**, 想保留得显式写 `const auto&` / `auto&`; decltype 则精确保留声明类型
 
 ```cpp
-const int ci = 1;
-int n = 2;
-int& ri = n;
+int a = 1;
+int &b = a;
+const int c = 1;
+const int &d = c;
 
-auto a = ci;          // int —— 顶层 const 被剥离
-auto b = ri;          // int —— 引用被剥离, b 是 n 的独立副本
+auto a1 = a; // int
+auto b1 = b; // int
+auto c1 = c; // int
+auto d1 = d; // int
 
-const auto& r1 = ci;  // const int& —— 用 const auto& 保留
-auto&& r2 = ci;       // const int& —— 万能引用按需保留
+const auto c2 = c;  // const int
+const auto &d2 = d; // const int &
 
-decltype(ci) d = ci;  // const int —— decltype 精确保留
+decltype(c) c3 = c; // const int
+decltype(d) d3 = d; // const int &
 ```
 
 这也解释了前面「类/结构体成员类型推导」里 `auto a = obj.a;` 为什么得到的是 `int` 而非 `const int` —— 顶层 const 被 auto 剥离了

videos/README.md

@@ -2,19 +2,47 @@
 
 ## 动画代码
 
-```python
-# manim -pql videos/[cppxx]/[filename].py
-manim -pql videos/cpp11/09-list-initialization.py
+> Manim Community v0.18.1。manim 本体由 uv 装(纯 pip);pycairo/manimpango 的原生依赖
+> —— xcb-free 的 cairo/pango 图形栈 —— 用 xlings 装进项目 subos,免去系统 gcc 的 xcb 坑。
+
+```bash
+# 1. 一次性:装图形栈 + uv 进项目 subos(cairo/pango 的 deps 自动拉全树)
+xlings install cairo pango uv
+
+# 2. 渲染:用启动器(已封装 PKG_CONFIG_PATH / uv 依赖 / pygments pin,免手输环境变量)
+videos/render.sh cpp11/00-auto-and-decltype.py          # 默认 -ql 快预览
+videos/render.sh cpp11/00-auto-and-decltype.py -qh      # 高清 1080p
+```
+
+<details>
+<summary>启动器封装了什么 / 手动等价命令</summary>
+
+`videos/render.sh <场景> [manim参数]` 等价于(在仓库根执行):
+
+```bash
+SR=$PWD/.xlings/subos/_/usr          # 项目匿名 subos —— xlings install 装在这, xlings-gcc 默认也搜它
+PKG_CONFIG_PATH=$SR/lib/pkgconfig \
+  uv run --with "manim==0.18.1" --with "pygments==2.17.2" \
+  manim -ql videos/cpp11/00-auto-and-decltype.py
 ```
 
-> Note: Manim Community v0.18.1
+- `PKG_CONFIG_PATH` 指向项目 subos,让 pkg-config 命中 **xcb-free cairo**(而非宿主 apt 带 xcb 的)——仅首次/清缓存后编译 pycairo/manimpango 时需要,编好的 wheel 被 uv 缓存后可省。
+- `pygments==2.17.2` 避开 manim 0.18.1 的 `Code` 渲染 `#CCC` bug。
+- **兜底**(没装生态栈时,用系统 gcc 绕开 xlings-gcc 的 xcb 坑):
+  ```bash
+  CC=/usr/bin/gcc CXX=/usr/bin/g++ \
+    uv run --with "manim==0.18.1" --with "pygments==2.17.2" \
+    manim -ql videos/cpp11/00-auto-and-decltype.py
+  ```
+</details>
 
 ## 视频列表
 
 | c++标准 | 特性 | 标题 | 练习代码/视频 | 备注 |
 | --- | --- | --- | --- | --- |
 | **引导** | `项目使用教程/引导` | hello mcpp | [docs](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/base/chapter_1.md) / [code](/dslings/hello-mcpp.cpp) / [video](https://www.bilibili.com/video/BV182MtzPEiX?p=2) | |
-| **cpp11** | `00 - auto和decltype` | 类型自动推导 | [docs](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md) / [code](/dslings/cpp11/00-auto-and-decltype-0.cpp) / [video](https://www.bilibili.com/video/BV1xkdYYUEyH) | |
+| **cpp11** | `00 - auto和decltype` | 类型自动推导 | [docs](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md) / [code](/videos/cpp11/00-auto-and-decltype.py) / [video](https://www.bilibili.com/video/BV1EzJs6HEf7) | |
+| | | 练习讲解 | [code](/dslings/cpp11/00-auto-and-decltype-0.cpp) / [video](https://www.bilibili.com/video/BV1xkdYYUEyH) | |
 | | | decltype注意事项 | [code](/dslings/cpp11/00-auto-and-decltype-4.cpp) / [video](https://www.bilibili.com/video/BV1KWoMYUEzW) | [补充](https://forum.d2learn.org/topic/82) |
 | | `01 - default和delete` | 控制默认构造函数生成 | [code](/dslings/cpp11/01-default-and-delete-0.cpp) / [video](https://www.bilibili.com/video/BV1B35pz5EN2) | |
 | | | 类型对象行为控制示例 | [code](/dslings/cpp11/01-default-and-delete-1.cpp) / [video](https://www.bilibili.com/video/BV1Vg5tznE8o) | |