update lambda abt auto

Author: archibate

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.12)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 
 project(main)
 

docs/lambda.md

@@ -2358,12 +2358,186 @@ TODO：`std::less` 和 `std::bind`
 
 ### 函数指针是 C 语言陋习，改掉
 
+无法保存状态
+
 ## lambda 进阶案例
 
 ### lambda 实现递归
 
+```cpp
+int fib(int n) {
+    if (n <= 2) {
+        return 1;
+    }
+    return fib(n - 1) + fib(n - 2);
+}
+```
+
+以上代码是众所周知的，典中典之斐波那契数列第 n 项的递归求法。
+
+然而这需要定义一个全局函数 fib，污染了全局名字空间不说，还无法捕获到局部变量。
+
+有时你可能希望在局部定义一个递归函数，就适合用 Lambda 语法，在一个现有的函数体内就地创建 Lambda 函数对象，而无需污染全局。
+
+```cpp
+int main() {
+    auto fib = [&] (int n) {
+        if (n <= 2) {
+            return 1;
+        }
+        return fib(n - 1) + fib(n - 2);
+    };
+}
+```
+
+然而以上代码会编译出错！因为 `fib` 的**初始化定义**用的表达式 `[&] (int n) { return fib(); }` 用到了 `fib` 自己！
+
+#### 初始化定义可以包含自己？！
+
+那 C++ 中，什么情况下一个变量的**初始化定义**可以包含自己呢？让我们回顾一下：
+
+```cpp
+int i = i + 1;
+```
+
+虽然编译能够通过，显然会产生运行时未定义行为。
+
+因为在执行变量 `i` 的初始化定义表达式 `i + 1` 时，`i` 还没有初始化呢！读取未初始化的变量是未定义行为。
+
+```cpp
+int i = (int) &i;
+```
+
+可以编译通过（假设为 32 位环境）。
+
+则是允许的，因为虽然 `i` 的初始化表达式 `(int) &i` 包含了尚未初始化的自己 `i`，但却是以他的地址形态出现的（使用了取地址运算符 `&`）。
+
+也就是说我们初始化 `i` 只是用到了 `i` 变量的地址 `&i`，而不是用到 `i` 里面的值。
+
+用变量自己的地址，初始化自己的值，没有问题。
+
+因为一个变量的生命周期中，总是先确定了其地址，再初始化其中的值的；无论是 new 还是局部变量，都是先有地址再初始化其值。
+
+> {{ icon.tip }} 顺序：分配地址 -> 初始化值
+
+所以我们初始化 `fib` 的表达式中，用 `[&]` 捕获了 `fib` 自己的引用（变量的地址），是没问题的。
+
+#### `auto` 才是罪魁祸首
+
+真正导致无法编译的问题在于：我们使用 `auto` 来推导 `fib` 的类型，而 `auto` 变量的类型，取决于右侧表达式的类型，必须先知道右侧表达式的类型，才能知道变量是什么类型，才能为变量分配地址，然后赋初始值。
+
+> {{ icon.tip }} 顺序：确定类型 -> 分配地址 -> 初始化值
+
+分配地址需要用到类型信息，而 `auto` 变量的类型信息取决于右侧表达式的类型。
+
+要知道右侧表达式的类型，就需要右侧表达式完成编译。
+
+而右侧表达式中包含了 `fib` 变量自己的引用捕获 `[&]`。
+
+这导致 `fib` 的类型还没有确定时，就需要被捕获进 Lambda 了，这就出现了循环引用，编译不通过。
+
+> {{ icon.fun }} 一场由 `auto` 推导机制引发的血案。
+
+#### 写明类型
+
+要避免这种循环引用，我们只能避免使用 `auto`，在 `fib` 定义中，就写一个具体的类型。
+
+```cpp
+int main() {
+    std::function<int(int)> fib = [&] (int n) {
+        if (n <= 2) {
+            return 1;
+        }
+        return fib(n - 1) + fib(n - 2);
+    };
+}
+```
+
+`function` 类型的大小，在 `fib` 初始化之前就已经确定，与 `fib` 初始化为什么值无关。
+
+这样在编译 `fib` 的初始化表达式时，`fib` 就是已经确定类型，并分配好内存地址了的，就可以被他自己的初始化表达式中的 Lambda 捕获。
+
+#### 性能焦虑！
+
+但是有的同学说，`function` 是类型擦除容器，虽然很方便，但是低性能呀？我有性能焦虑症😩，能不能还用 `auto` 呀？
+
+的确，因为 Lambda 表达式本身的类型是一个匿名类型，并不是 `function<int(int)>` 类型，这之间发生了隐式转换。
+
+为了伺候你的性能焦虑😩，小彭老师隆重介绍一种能让 Lambda 递归的 C++23 语法 deducing-this：
+
+```cpp
+auto fib = [] (this auto &self, int n) {
+    if (n <= 2) {
+        return 1;
+    }
+    return self(n - 1) + self(n - 2);
+};
+```
+
+且无需用 `[&]` 捕获 `fib` 自己，用 `self` 这个特殊的参数就能访问到自身的引用！
+
+之前也说了，Lambda 无非是编译器自动帮你生成了一个带有 `operator()` 成员函数的匿名类，他实际上等价于：
+
+```cpp
+struct Fib {
+    int operator()(int n) const {
+        if (n <= 2) {
+            return 1;
+        }
+        return (*this)(n - 1) + (*this)(n - 2);  // deducing-this 定义的 self 引用等价于 *this
+    };
+};
+auto fib = Fib();
+```
+
+毕竟 `this` 是调用 `Fib::operator()` 时本来就会传入的参数，根本没必要储存在 `Fib` 类型体内，更节省了内存。
+
+只是由于 C++23 之前在 Lambda 体内写 this，含义是外部类的指针，而不是 Lambda 对象自己的 this 指针。
+
+所以 C++23 才提出了 deducing-this，把本就属于 Fib 的 this 作为参数传入，获取 Lambda 自己的地址。
+
+> {{ icon.tip }} deducing-this 的语法固定为 `this auto`，这里的 `auto` 会自动推导为当前 Lambda 对象的类型（是个匿名类）。而前缀 `this` 是固定的语法，无特殊含义。
+
+#### 没有 C++23？
+
+如果你无法使用 C++23，还患有性能焦虑，不想用 function，还有一种小技巧可以让 Lambda 支持递归：在参数中传入自身的引用！
+
+```cpp
+auto fib = [] (auto &fib, int n) -> int {
+    if (n <= 2) {
+        return 1;
+    }
+    return fib(fib, n - 1) + fib(fib, n - 2);
+};
+```
+
+> {{ icon.detail }} 这在函数式编程范式中称为“自递归”技巧，可以让无法一个捕获到自身的匿名函数对象也能实现递归自我调用。
+
+缺点：
+
+1. 每次使用时就需要把 `fib` 作为引用参数传入用自己！
+
+```cpp
+fib(fib, 1);
+```
+
+2. 必须写明返回类型 `-> int`，否则编译会失败！
+
+因为 C++ 编译器递归解析表达式的设计，需要先确定 Lambda 表达式中每一条子语句————例如 `fib(fib, n - 1)`————的返回类型，才能确定 Lambda 自身的返回类型。
+
+而 `fib(fib, n - 1)` 这个表达式又需要用到 `fib` 的类型，其又进一步需要 `fib` 自身体内每一条子语句，也就是 `fib(fib, n - 1)` 的类型，无限递归，无法确定唯一的类型，编译器只能报错。
+
+> {{ icon.warn }} 使用这种“自递归”技巧的 Lambda，哪怕没有返回值，也必须写明 `-> void`！非常麻烦……
+
 ### lambda 避免全局重载函数捕获为变量时恼人的错误
 
+```cpp
+void print(int i);
+void print(std::string s);
+
+auto f = print; // 出错！无法确定是哪一个重载！
+```
+
 ### lambda 配合 if-constexpr 实现编译期三目运算符
 
 ### 推荐用 C++23 的 `std::move_only_function` 取代 `std::function`

examples/error_code.cpp

@@ -1,5 +1,6 @@
 #include <fmt/core.h>
 #include <system_error>
+#include <span>
 #include "tl-expected.hpp"
 #include <fcntl.h>
 // 今日主题：现代 C++ 中的错误处理
@@ -139,54 +140,54 @@ int main() {
     return 0;
 }
 
-namespace screenshot1 {
-
-namespace std {
-using namespace ::tl;
-using namespace ::std;
-}
-
-std::expected<int, std::error_code> expectedStdError(int ret) {
-    if (ret == -1) {
-        return std::unexpected{std::error_code(errno, std::generic_category())};
-    }
-    return ret;
-}
-
-struct File {
-    int fd;
-
-    explicit File(const char *path, int flags) {
-        fd = expectedStdError(::open(path, flags)).value();
-    }
-
-    tl::expected<size_t, std::error_code> write(std::span<const char> buf) {
-        return expectedStdError(::write(fd, buf.data(), buf.size()));
-    }
-};
-
-std::expected<int, std::error_code> sqrt(int x) {
-    if (x < 0)
-        return std::unexpected{make_error_code(std::errc::argument_out_of_domain)};
-
-    for (int i = 0;; i++)
-        if (i * i >= x)
-            return i;
-}
-
-}
-
-namespace screenshot2 {
-
-int sqrt(int x) {
-    if (x < 0) {
-        errno = EDOM;
-        return -1;
-    }
-
-    for (int i = 0;; i++)
-        if (i * i >= x)
-            return i;
-}
-
-}
+// namespace screenshot1 {
+//
+// namespace std {
+// using namespace ::tl;
+// using namespace ::std;
+// }
+//
+// std::expected<int, std::error_code> expectedStdError(int ret) {
+//     if (ret == -1) {
+//         return std::unexpected{std::error_code(errno, std::generic_category())};
+//     }
+//     return ret;
+// }
+//
+// struct File {
+//     int fd;
+//
+//     explicit File(const char *path, int flags) {
+//         fd = expectedStdError(::open(path, flags)).value();
+//     }
+//
+//     tl::expected<size_t, std::error_code> write(std::span<const char> buf) {
+//         return expectedStdError(::write(fd, buf.data(), buf.size()));
+//     }
+// };
+//
+// std::expected<int, std::error_code> sqrt(int x) {
+//     if (x < 0)
+//         return std::unexpected{make_error_code(std::errc::argument_out_of_domain)};
+//
+//     for (int i = 0;; i++)
+//         if (i * i >= x)
+//             return i;
+// }
+//
+// }
+//
+// namespace screenshot2 {
+//
+// int sqrt(int x) {
+//     if (x < 0) {
+//         errno = EDOM;
+//         return -1;
+//     }
+//
+//     for (int i = 0;; i++)
+//         if (i * i >= x)
+//             return i;
+// }
+//
+// }