book: add SFINAE and std::enable_if section

Add a 2.5 subsection explaining SFINAE (with std::enable_if and
expression SFINAE via decltype) as the pre-C++20 way to constrain
templates, and point forward to C++20 concepts as the modern
replacement. Compiled example code/2/2.28. Resolves #150

Author: changkun

book/en-us/02-usability.md

@@ -927,6 +927,38 @@ int main() {
 }
 ```
 
+### SFINAE and `std::enable_if`
+
+SFINAE stands for "Substitution Failure Is Not An Error". It describes the rule that, when substituting template arguments produces an invalid type or expression in the **immediate context**, the compiler does not raise an error but silently removes that candidate from the overload set. This was the main way to constrain template parameters before C++20's concepts.
+
+The most common tool is `std::enable_if` from `<type_traits>`. The `describe` below is visible only for integral types:
+
+```cpp
+#include <type_traits>
+
+template <typename T,
+          typename = std::enable_if_t<std::is_integral_v<T>>>
+void describe(T) {
+    std::cout << "integral" << std::endl;
+}
+
+describe(42);   // OK
+// describe(3.14); // compile error: floating point does not satisfy the constraint
+```
+
+Another common form is **expression SFINAE**, which uses `decltype` to probe whether an expression is valid, thereby detecting at compile time whether a type has a certain capability:
+
+```cpp
+// participates only if c.size() is a valid expression
+template <typename T>
+auto has_size(const T& c) -> decltype(c.size(), std::true_type{}) {
+    return std::true_type{};
+}
+std::false_type has_size(...) { return std::false_type{}; }
+```
+
+SFINAE is powerful but obscure to write and produces verbose error messages. C++20's [concepts](./10-cpp20.md#concept-and-constraints) were introduced precisely to express such constraints in a more intuitive and readable way, and can be regarded as the modern replacement for SFINAE.
+
 ## 2.6 Object-oriented
 
 ### Delegate constructor

book/zh-cn/02-usability.md

@@ -833,6 +833,38 @@ int main() {
 }
 ```
 
+### SFINAE 与 `std::enable_if`
+
+SFINAE 是 “Substitution Failure Is Not An Error”（替换失败并非错误）的缩写。它描述的是这样一条规则：在对模板参数进行替换时，如果在**直接上下文 (immediate context)** 中产生了非法的类型或表达式，编译器并不会报错，而是悄悄地把这个候选从重载集合中剔除。这正是在 C++20 的 concept 出现之前，对模板参数进行约束的主要手段。
+
+最常见的工具是 `<type_traits>` 中的 `std::enable_if`。下面的 `describe` 只对整型可见：
+
+```cpp
+#include <type_traits>
+
+template <typename T,
+          typename = std::enable_if_t<std::is_integral_v<T>>>
+void describe(T) {
+    std::cout << "integral" << std::endl;
+}
+
+describe(42);   // 正确
+// describe(3.14); // 编译错误：浮点类型不满足约束，该重载被剔除
+```
+
+另一种常见形式是**表达式 SFINAE**，它借助 `decltype` 来探测某个表达式是否合法，从而在编译期检测类型是否具备某种能力：
+
+```cpp
+// 当且仅当 c.size() 是合法表达式时，这个重载才会参与候选
+template <typename T>
+auto has_size(const T& c) -> decltype(c.size(), std::true_type{}) {
+    return std::true_type{};
+}
+std::false_type has_size(...) { return std::false_type{}; }
+```
+
+SFINAE 虽然强大，但写法晦涩、错误信息冗长。C++20 的 [概念 (concept)](./10-cpp20.md#概念与约束) 正是为了以更直观、可读的方式表达这类约束而引入的，可以将其视为 SFINAE 的现代替代品。
+
 ## 2.6 面向对象
 
 ### 委托构造

code/2/2.28.sfinae.cpp

@@ -0,0 +1,41 @@
+//
+// 2.28.sfinae.cpp
+// chapter 2 language usability
+// modern cpp tutorial
+//
+// created by changkun at changkun.de
+// https://github.com/changkun/modern-cpp-tutorial
+//
+
+#include <iostream>
+#include <type_traits>
+#include <vector>
+
+// SFINAE ("Substitution Failure Is Not An Error"): when substituting
+// template arguments produces an invalid type/expression in the
+// immediate context, that overload is silently removed from the
+// candidate set instead of causing a hard error.
+
+// 1) Constrain with std::enable_if: this overload exists only for
+//    integral types.
+template <typename T,
+          typename = std::enable_if_t<std::is_integral_v<T>>>
+void describe(T) {
+    std::cout << "integral" << std::endl;
+}
+
+// 2) Expression SFINAE: this overload participates only if `c.size()`
+//    is a valid expression.
+template <typename T>
+auto has_size(const T& c) -> decltype(c.size(), std::true_type{}) {
+    return std::true_type{};
+}
+std::false_type has_size(...) { return std::false_type{}; }
+
+int main() {
+    describe(42); // integral
+
+    std::cout << std::boolalpha;
+    std::cout << has_size(std::vector<int>{1, 2, 3}) << std::endl; // true
+    std::cout << has_size(42) << std::endl;                        // false
+}