C++20 Concepts 深度实战 on Dorkytiger 的小屋

一、Concepts 到底解决了什么问题？

Mon, 01 Jan 0001 00:00:00 +0000

没有 Concepts 的 C++：

template <typename T>
T twice(T x) {
    return x + x;
}

twice(42);           // ✅ 正常
twice("hello"s);     // ✅ 正常（string 可以 +）
twice(std::mutex{}); // ❌ 编译报错，5 万行报错信息！！

错误信息长啥样？

error: no match for 'operator+' (operand types are 'std::mutex' and 'std::mutex')
  note: candidate: 'std::mutex::mutex(const std::mutex&)' <near match>
  note: conversion of argument 1 would be ill-formed
  ... (50 行后续错误)
  ... (深入各种模板实例化失败上下文)
  ... (100 行库内部代码)

有了 Concepts 的 C++ 20：

二、Concepts 的三种写法（看起来不一样，效果一样）

Mon, 01 Jan 0001 00:00:00 +0000

// 写法 1：template 前缀约束（最推荐，一眼看出模板类型受约束）
template <std::integral T>
T half(T x) { return x / 2; }

// 写法 2：auto 参数约束（简洁，类似泛型 lambda）
std::integral auto half(std::integral auto x) { return x / 2; }

// 写法 3：requires 子句（最灵活，可以写复杂条件）
template <typename T>
    requires std::integral<T>
T half(T x) { return x / 2; }

选哪个？

场景 1：约束很简单（比如 std::integral、std::floating_point）→ 写法 1 或 2 都行。
场景 2：约束复杂（多个条件组合）→ 定义新 Concept + 写法 1。
场景 3：约束依赖多个模板参数 → requires 子句最自然。

三、四种 requires 表达式——到底怎么读？

Mon, 01 Jan 0001 00:00:00 +0000

template <typename T>
concept Example = requires(T a, T b) {
    // ① 简单要求：这个表达式必须能编译
    a + b;          // T 必须支持 operator+(T, T)
    a.begin();      // T 必须有 begin() 成员

    // ② 类型要求：这个类型必须存在
    typename T::value_type;   // T 必须有 value_type 成员类型
    typename T::iterator;     // T 必须有 iterator 成员类型

    // ③ 复合要求：表达式必须有特定返回类型
    { a * b } -> std::convertible_to<int>;
    // a * b 必须能编译，且结果能隐式转 int

    // ④ 嵌套要求：里面的约束必须满足
    requires std::is_destructible_v<T>;
    // T 必须是可析构的
};

理解方式：把 requires(...) 读作**“检查这些代码能否编译通过”**。如果里面所有代码都能编译，Concept 为 true，否则为 false。

四、四个最常用的标准 Concepts

Mon, 01 Jan 0001 00:00:00 +0000

// 1. std::same_as —— 精确类型匹配
// 用于需要精确匹配的 API
void process(std::same_as<int> auto x);  // 只接受 int，不接受 long

// 2. std::convertible_to —— 可隐式转换
// 用于返回值约束
{ func() } -> std::convertible_to<int>;  // func 的返回值可以被赋给 int

// 3. std::invocable —— 可调用对象
// 用于接受回调的泛型函数
template <std::invocable<int, double> F>
void register_callback(F&& callback);    // F 必须是 f(int, double) 这种签名

// 4. std::range —— 容器/范围
// 替代传统 iterator pair
template <std::range R>
void sort_all(R& r);                     // 接受 vector, list, array, span...

五、实战：什么时候自定义 Concept？

Mon, 01 Jan 0001 00:00:00 +0000

场景：你有一个序列化框架，需要约束参数类型必须支持 serialize 和 deserialize：

// 定义业务相关的 Concept
template <typename T>
concept Serializable = requires(T obj, std::ostream& os, std::istream& is) {
    { obj.serialize(os) } -> std::same_as<void>;
    { obj.deserialize(is) } -> std::same_as<void>;
};

// 使用——读代码的人一眼就知道 T 需要什么能力
template <Serializable T>
void save_to_file(const T& obj, const std::string& path) {
    std::ofstream os(path);
    obj.serialize(os);
}

template <Serializable T>
T load_from_file(const std::string& path) {
    T obj;
    std::ifstream is(path);
    obj.deserialize(is);
    return obj;
}

如果不自定义 Concept 会怎样？

六、面试高频题：Concepts vs SFINAE

Mon, 01 Jan 0001 00:00:00 +0000

对比维度	SFINAE	Concepts
报错信息	几十行库内部模板实例化堆栈	一行"不满足 XXX 约束"
代码可读性	`enable_if<is_integral_v<T> && !is_same_v<T, char>>`	`requires Integral<T> && !SameAs<T, char>`
复用性	每次写一次条件表达式	定义一次 Concept，到处用
编译时间	长（大量模板实例化尝试）	短（约束在模板实例化前检查）
重载优先级	靠 SFINAE 的"最匹配"规则	自然支持 Concept 偏序（更特化的优先）

结论：C++20 项目优先用 Concepts。只有需要兼容 C++17 时才保留 SFINAE。