feat(vol4): 元编程子卷 concepts 三连

vol4-advanced/vol3-metaprogramming-cpp20-23 子卷前三篇:
- 01 Concepts 详解(四种语法形式/enable_if 报错对比/标准库概念)
- 02 约束模板(subsumption 与重载/原子约束真包含)
- 03 requires 表达式(四种成分/不求值/硬错误坑)
配套 9 个示例;报错演示用 -D 宏切换。index 改正式导航。

Author: Charliechen114514

README.md

@@ -20,7 +20,7 @@
 ---
 
 <!-- COVERAGE_START -->
-![English Coverage](https://img.shields.io/badge/en_coverage-100%25-green.svg) 602/604 docs translated
+![English Coverage](https://img.shields.io/badge/en_coverage-99%25-green.svg) 602/607 docs translated
 <!-- COVERAGE_END -->
 
 ## 这是什么项目

code/examples/vol4/vol3-metaprogramming-cpp20-23/concept_pitfalls.cpp

@@ -0,0 +1,56 @@
+// Concepts 的三个经典坑,用宏切换复现(默认编译干净,加宏触发对应坑的编译失败)
+// 对应文章:02-constraining-templates.md、03-requires-expressions.md
+//
+// 默认编译(干净,main 演示「用 concept 包装优雅判断负例」的解法):
+//   g++ -Wall -Wextra -std=c++20 concept_pitfalls.cpp -o cp && ./cp
+// 复现三个坑(每个都会编译失败,对照文章看报错):
+//   g++ -std=c++20 -DDEMO_AMBIGUITY  concept_pitfalls.cpp   # 坑一:两个互不蕴含的 concept 重载,Duck
+//   同时满足 -> 歧义 g++ -std=c++20 -DDEMO_NOSUBSUME  concept_pitfalls.cpp   # 坑二:C2=C1<T>
+//   规范化后原子约束与 C1 相同,不 subsume -> 歧义 g++ -std=c++20 -DDEMO_HARD_ERROR
+//   concept_pitfalls.cpp   # 坑三:对具体类型直接写 requires 表达式 -> 硬错误
+#include <iostream>
+#include <string>
+
+// 坑一用:两个彼此独立的 concept,谁也不蕴含谁
+template <typename T>
+concept Swimmable = requires(T t) { t.swim(); };
+template <typename T>
+concept Flyable = requires(T t) { t.fly(); };
+void act(Swimmable auto) {}
+void act(Flyable auto) {}
+
+// 坑二用:C2 只是 C1<T> 换名,没有额外原子约束
+template <typename T>
+concept C1 = requires(T t) { t.a(); };
+template <typename T>
+concept C2 = C1<T>;
+void g(C1 auto) {}
+void g(C2 auto) {}
+
+// 坑三的解法:把 requires 表达式包进 concept,求值时 T 是模板参数 -> SFINAE 友好,失败返回 false
+// 而非硬错误
+template <typename T>
+concept HasNope = requires(T t) { t.nope(); };
+
+struct Duck {
+    void swim() {}
+    void fly() {}
+};
+struct X {
+    void a() {}
+};
+
+int main() {
+    std::cout << std::boolalpha;
+    // 解法演示:concept 包装后,不存在的成员优雅返回 false
+    std::cout << "HasNope<std::string>: " << HasNope<std::string> << "\n"; // false,不硬错误
+
+#if DEMO_AMBIGUITY
+    act(Duck{}); // Duck 同时满足 Swimmable 和 Flyable,两者互不蕴含 -> 编译器选不出 -> 歧义
+#elif DEMO_NOSUBSUME
+    g(X{}); // X 同时满足 C1 和 C2,但 C2 规范化后原子约束= C1,无真包含 -> 歧义
+#elif DEMO_HARD_ERROR
+    static_assert(!requires(std::string s) { s.nope(); }); // 对具体类型 string 直接写 -> 硬错误
+#endif
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/concepts_four_forms.cpp

@@ -0,0 +1,41 @@
+// Concepts 的四种语法形式:把约束写进模板参数、requires 子句、简写 auto、内嵌 requires 表达式
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/01-concepts.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 concepts_four_forms.cpp -o four_forms && ./four_forms
+#include <concepts>
+#include <iostream>
+#include <string>
+
+template <typename T>
+concept Numeric = std::integral<T> || std::floating_point<T>;
+
+// 形式①:把 concept 直接当约束写在模板参数列表里
+template <Numeric T> T form1(T a, T b) {
+    return a + b;
+}
+
+// 形式②:requires 子句(trailing requires-clause)
+template <typename T>
+    requires Numeric<T>
+T form2(T a, T b) {
+    return a + b;
+}
+
+// 形式③:简写模板语法(constrained auto)
+auto form3(Numeric auto a, Numeric auto b) {
+    return a + b;
+}
+
+// 形式④:模板参数列表后跟 requires,内层是一个 requires 表达式
+template <typename T>
+    requires requires(T x) { x + x; }
+T form4(T a, T b) {
+    return a + b;
+}
+
+int main() {
+    std::cout << "form1: " << form1(3, 5) << "\n";
+    std::cout << "form2: " << form2(2.0, 3.0) << "\n";
+    std::cout << "form3: " << form3(10, 20) << "\n";
+    std::cout << "form4: " << form4(std::string("a"), std::string("b")) << "\n";
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/constraints_everywhere.cpp

@@ -0,0 +1,39 @@
+// concept 约束可以用在函数模板、类模板、成员函数、简写 auto 等多种位置
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/02-constraining-templates.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 constraints_everywhere.cpp -o ce && ./ce
+#include <concepts>
+#include <iostream>
+
+template <typename T>
+concept Numeric = std::integral<T> || std::floating_point<T>;
+
+// ① 函数模板
+template <Numeric T> T square(T x) {
+    return x * x;
+}
+
+// ② 类模板:只对数值类型实例化
+template <Numeric T> struct SafeNumber {
+    T value;
+    SafeNumber(T v) : value(v) {}
+    // ③ 成员函数也能再加自己的约束
+    SafeNumber& operator+=(Numeric auto other) {
+        value += other;
+        return *this;
+    }
+};
+
+// ④ 简写语法:约束直接写在 auto 前
+Numeric auto half(Numeric auto x) {
+    return x / 2;
+}
+
+int main() {
+    std::cout << "square(4) = " << square(4) << "\n";
+    std::cout << "square(2.5) = " << square(2.5) << "\n";
+    SafeNumber sn(3);
+    sn += 4;
+    std::cout << "SafeNumber(3) + 4 = " << sn.value << "\n";
+    std::cout << "half(10) = " << half(10) << "\n";
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/enable_if_vs_concept.cpp

@@ -0,0 +1,49 @@
+// enable_if vs concept 的报错对比:同一个 add,两种约束方式,故意传错类型看报错差异
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/01-concepts.md
+//
+// 默认编译(演示两个 add 都能正常工作):
+//   g++ -Wall -Wextra -std=c++20 enable_if_vs_concept.cpp -o eic && ./eic
+//
+// 复现报错对比(分别加宏编译,看 concept 报错如何直接点名约束、enable_if 版暴露 SFINAE 内部):
+//   g++ -std=c++20 -DDEMO_OLD enable_if_vs_concept.cpp    # enable_if 版报错
+//   g++ -std=c++20 -DDEMO_NEW enable_if_vs_concept.cpp    # concept 版报错(constraints not
+//   satisfied)
+#include <concepts>
+#include <iostream>
+#include <string>
+#include <type_traits>
+
+namespace old_way {
+// C++17 的 enable_if:把约束塞进额外的默认模板参数
+template <typename T,
+          typename = std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>>>
+T add(T a, T b) {
+    return a + b;
+}
+} // namespace old_way
+
+namespace new_way {
+// C++20 concept:约束写进签名,有名字、可复用
+template <typename T>
+concept Numeric = std::integral<T> || std::floating_point<T>;
+
+template <typename T>
+    requires Numeric<T>
+T add(T a, T b) {
+    return a + b;
+}
+} // namespace new_way
+
+int main() {
+    std::cout << "old_way::add(2, 3) = " << old_way::add(2, 3) << "\n";
+    std::cout << "new_way::add(2, 3) = " << new_way::add(2, 3) << "\n";
+
+#if DEMO_OLD
+    std::string s1 = "a", s2 = "b";
+    old_way::add(s1, s2); // 故意传错:看 enable_if 版报错(no type named 'type' in enable_if<false>)
+#elif DEMO_NEW
+    std::string s1 = "a", s2 = "b";
+    new_way::add(s1, s2); // 故意传错:看 concept 版报错(constraints not satisfied -> Numeric<T>)
+#endif
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/requires_expression.cpp

@@ -0,0 +1,35 @@
+// Requires 表达式四种成分(简单/类型/复合/嵌套)+ 当 bool 用 + 用表达式定义 concept
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/03-requires-expressions.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 requires_expression.cpp -o req && ./req
+#include <concepts>
+#include <iostream>
+#include <vector>
+
+// 四种成分一次用全:简单要求、类型要求、复合要求、嵌套要求
+template <typename T>
+concept Container = requires(T t) {
+    t.begin(); // ① 简单要求
+    t.end();
+    typename T::value_type;                           // ② 类型要求
+    { t.size() } -> std::convertible_to<std::size_t>; // ③ 复合要求
+    requires std::integral<typename T::value_type>;   // ④ 嵌套要求
+};
+
+static_assert(Container<std::vector<int>>); // value_type=int,integral 通过
+static_assert(!Container<int>);             // int 没有 begin/end
+
+// requires 表达式当 bool 用:if constexpr 里直接判断
+template <typename T> void process(T t) {
+    (void)t;
+    if constexpr (requires(T x) { x.empty(); }) {
+        std::cout << "has empty()\n";
+    } else {
+        std::cout << "no empty()\n";
+    }
+}
+
+int main() {
+    process(std::vector<int>{}); // vector 有 empty()
+    process(42);                 // int 没有
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/same_as_pitfall.cpp

@@ -0,0 +1,30 @@
+// same_as 的两个坑:same_as<int,const int> 为 false(cv 限定让它们成为不同类型);concept 当 is_same
+// 误用 对应文章:01-concepts.md、02-constraining-templates.md 编译运行:g++ -Wall -Wextra -std=c++20
+// same_as_pitfall.cpp -o sas && ./sas
+#include <concepts>
+#include <iostream>
+#include <type_traits>
+
+// 坑二:concept 当 is_same 用,把 T 锁死成 int
+// 能跑,但这种「锁死成具体类型」通常不如直接写非模板函数 void only_int(int) 清楚
+template <std::same_as<int> T> void only_int(T x) {
+    std::cout << "got int: " << x << "\n";
+}
+// same_as 真正的用武之地是约束两个参数的关系:
+// template <typename A, typename B> requires std::same_as<A, B>
+
+int main() {
+    std::cout << std::boolalpha;
+
+    // 坑一:const 限定让 int 和 const int 成为不同类型,same_as 返回 false
+    std::cout << "same_as<int, const int>:                 "
+              << std::same_as<int, const int> << "\n"; // false
+    // 想判断「剥掉 cv/引用后是否相同」,先用 remove_cvref_t
+    std::cout << "same_as<int, remove_cvref_t<const int>>: "
+              << std::same_as<int, std::remove_cvref_t<const int>> << "\n"; // true
+
+    // 坑二演示:only_int 只收 int
+    only_int(42);
+    // only_int(3.14);   // 编译失败:double 不满足 same_as<int>
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/stdconcepts_demo.cpp

@@ -0,0 +1,26 @@
+// 标准库 <concepts> 常用概念实测:same_as / convertible_to / derived_from / common_with / integral /
+// floating_point 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/01-concepts.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 stdconcepts_demo.cpp -o stdc && ./stdc
+#include <concepts>
+#include <iostream>
+#include <vector>
+
+struct Base {};
+struct Derived : Base {};
+struct Unrelated {};
+
+int main() {
+    std::cout << std::boolalpha;
+    std::cout << "same_as<int,int>:             " << std::same_as<int, int> << "\n";
+    std::cout << "same_as<int, const int>:      " << std::same_as<int, const int> << "\n";
+    std::cout << "convertible_to<int,double>:   " << std::convertible_to<int, double> << "\n";
+    std::cout << "convertible_to<double,int>:   " << std::convertible_to<double, int> << "\n";
+    std::cout << "derived_from<Derived,Base>:   " << std::derived_from<Derived, Base> << "\n";
+    std::cout << "derived_from<Unrelated,Base>: " << std::derived_from<Unrelated, Base> << "\n";
+    std::cout << "common_with<int,double>:      " << std::common_with<int, double> << "\n";
+    std::cout << "default_initializable<int>:   " << std::default_initializable<int> << "\n";
+    std::cout << "integral<int>:                " << std::integral<int> << "\n";
+    std::cout << "integral<bool>:               " << std::integral<bool> << "\n";
+    std::cout << "floating_point<float>:        " << std::floating_point<float> << "\n";
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/subsumption_overloads.cpp

@@ -0,0 +1,54 @@
+// Subsumption(约束蕴含):多个带 concept 约束的重载,编译器靠约束的包含关系选最特定的
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/02-constraining-templates.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 subsumption_overloads.cpp -o sub && ./sub
+#include <iostream>
+
+// 第一组:Dog 蕴含 Animal(Dog = Animal<T> && 额外要求),subsumption 让更窄的重载胜出
+template <typename T>
+concept Animal = requires(T t) { t.eat(); };
+template <typename T>
+concept Dog = Animal<T> && requires(T t) { t.bark(); };
+
+void describe(Animal auto const&) {
+    std::cout << "an animal\n";
+}
+void describe(Dog auto const&) {
+    std::cout << "a dog\n";
+}
+
+// 第二组:&& 组合产生 {A<T>, B<T>} 原子约束集合,C 同时 subsumes A 和 B
+template <typename T>
+concept A = requires(T t) { t.a(); };
+template <typename T>
+concept B = requires(T t) { t.b(); };
+template <typename T>
+concept C = A<T> && B<T>;
+
+void f(A auto const&) {
+    std::cout << "A\n";
+}
+void f(B auto const&) {
+    std::cout << "B\n";
+}
+void f(C auto const&) {
+    std::cout << "C\n";
+}
+
+struct Cat {
+    void eat() {}
+};
+struct Pup {
+    void eat() {}
+    void bark() {}
+};
+struct Both {
+    void a() {}
+    void b() {}
+};
+
+int main() {
+    describe(Cat{}); // 只满足 Animal -> 宽重载
+    describe(Pup{}); // 满足 Dog -> 窄重载(subsumes 宽重载)
+    f(Both{});       // 同时满足 A、B、C -> C(subsumes A 和 B)
+    return 0;
+}

code/examples/vol4/vol3-metaprogramming-cpp20-23/unevaluated.cpp

@@ -0,0 +1,25 @@
+// requires 表达式不求值(unevaluated):里面的调用只检查能否编译,根本不执行、无副作用
+// 对应文章:documents/vol4-advanced/vol3-metaprogramming-cpp20-23/03-requires-expressions.md
+// 编译运行:g++ -Wall -Wextra -std=c++20 unevaluated.cpp -o ue && ./ue
+// 预期:concept 求值时 counter 仍为 0,只有 main 里真正调用 increment 才变 1
+#include <iostream>
+
+int counter = 0;
+int increment() {
+    ++counter;
+    std::cout << "[副作用] increment 被调用了\n";
+    return 1;
+}
+
+template <typename T>
+concept MentionsIncrement = requires(T t) {
+    increment(); // 只检查「这个调用合不合法」,不求值、不执行
+};
+
+int main() {
+    static_assert(MentionsIncrement<int>); // 满足:increment() 调用合法
+    std::cout << "concept 求值完毕,counter = " << counter << "\n";
+    increment(); // 这里才真正调用
+    std::cout << "真正调用后,counter = " << counter << "\n";
+    return 0;
+}