约束组合与重载决议

上一节我们学会了定义和使用单个 Concept。但真正的威力在于将约束组合起来,并利用编译器的约束排序规则实现基于类型能力的静态分发。本节将深入这一机制,让你像搭积木一样构建精确的类型约束体系。

1. 概念组合(Concept Composition)

Concept 可以通过逻辑运算符组合成更复杂的约束:

  • &&(合取 / conjunction)— 类型必须同时满足两个约束
  • ||(析取 / disjunction)— 类型至少满足其中一个约束
#include <concepts>
#include <type_traits>

// 合取:同时满足 integral 和 signed
template<typename T>
concept SignedInteger = std::integral<T> && std::is_signed_v<T>;

// 合取:可排序的容器
template<typename T>
concept SortableContainer =
    std::ranges::random_access_range<T> &&
    std::sortable<std::ranges::iterator_t<T>>;

// 析取:数值类型(整数或浮点)
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// 组合使用
template<SignedInteger T>
T absolute(T value) {
    return value < 0 ? -value : value;
}

// 测试
static_assert(SignedInteger<int>);          // OK:int 是有符号整数
static_assert(!SignedInteger<unsigned>);     // 失败:unsigned 无符号
static_assert(Numeric<double>);             // OK:浮点是 Numeric
static_assert(Numeric<int>);                // OK:整数也是 Numeric
static_assert(!Numeric<std::string>);       // 失败:string 不是数值

组合 vs 新建:优先通过组合现有 Concept 来构建新约束,而不是从头写 requires 表达式。标准库已经提供了大量原子概念(std::integral、std::floating_point、std::copyable 等),把它们当作积木来搭建即可。

更复杂的组合示例——可哈希且可比较的键类型:

// 可用作无序容器键的类型
template<typename T>
concept HashableKey =
    std::equality_comparable<T> &&
    requires(T a) {
        { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
    };

// 可用作有序容器键的类型
template<typename T>
concept OrderedKey = std::totally_ordered<T>;

// 通用键类型:能用于有序或无序容器
template<typename T>
concept AnyKey = HashableKey<T> || OrderedKey<T>;

2. requires requires(嵌套 requires)

有时你不想专门定义一个具名 Concept,只想在函数声明处临时写一个约束。这时会出现"双重 requires"的语法:

// 第一个 requires:引入约束子句(requires-clause)
// 第二个 requires:开始一个 requires 表达式(requires-expression)
template<typename T>
requires requires(T a, T b) {   // ← 两个 requires 各有含义
    { a + b } -> std::same_as<T>;
    { a * b } -> std::same_as<T>;
}
T multiply_add(T a, T b, T c) {
    return a * b + c;
}

分解这两个 requires 的角色:

// 等价的分步写法:
template<typename T>
concept Arithmetic = requires(T a, T b) {  // ← 这是 requires-expression
    { a + b } -> std::same_as<T>;
    { a * b } -> std::same_as<T>;
};

template<typename T>
requires Arithmetic<T>   // ← 这是 requires-clause
T multiply_add(T a, T b, T c) {
    return a * b + c;
}

避免滥用 requires requires:如果一个约束在多处使用,请提取为具名 Concept。requires requires 仅适合一次性的、简单的临时约束。过度使用会让代码难以阅读,并且编译器无法对匿名约束进行 subsumption 排序。

更多 requires requires 的实际场景:

// 约束:类型必须有 .serialize() 方法
template<typename T>
requires requires(const T& obj) {
    { obj.serialize() } -> std::convertible_to<std::string>;
}
void save(const T& obj) {
    auto data = obj.serialize();
    // ... 写入文件
}

// 约束:可以用 [] 下标访问
template<typename Container>
requires requires(Container c, std::size_t i) {
    { c[i] };
    { c.size() } -> std::convertible_to<std::size_t>;
}
auto get_last(const Container& c) {
    return c[c.size() - 1];
}

3. 约束排序(Constraint Subsumption)

约束排序是 C++20 Concepts 最精妙的设计之一:编译器能自动判断哪个约束"更严格",从而在重载决议中选择最匹配的版本。

核心规则:如果约束 A 在逻辑上蕴含约束 B(即满足 A 的类型必然满足 B),则 A 比 B 更受约束(more constrained),在重载决议中优先。

#include <concepts>
#include <iostream>

// 基础约束:任何类型
template<typename T>
void process(T value) {
    std::cout << "通用版本\n";
}

// 更严格:必须是 integral
template<std::integral T>
void process(T value) {
    std::cout << "整数版本\n";
}

// 最严格:必须是 signed_integral(蕴含 integral)
template<std::signed_integral T>
void process(T value) {
    std::cout << "有符号整数版本\n";
}

int main() {
    process(3.14);          // 通用版本(double 不满足 integral)
    process(42u);           // 整数版本(unsigned 满足 integral 但不满足 signed_integral)
    process(42);            // 有符号整数版本(int 满足 signed_integral)
}

蕴含关系的来源:标准库中 std::signed_integral 的定义是 std::integral<T> && std::is_signed_v<T>。因为它包含了 std::integral 作为合取的一部分,编译器可以推导出 signed_integral 蕴含 integral,从而判定它更受约束。

subsumption 只在约束由已命名的 Concept 合取/析取构成时生效:

// 正确:编译器能进行 subsumption
template<typename T>
concept A = std::integral<T>;

template<typename T>
concept B = std::integral<T> && (sizeof(T) >= 4);  // B 蕴含 A

template<A T> void foo(T);  // #1
template<B T> void foo(T);  // #2 —— B 更严格,优先

// 错误:匿名 requires 表达式无法参与 subsumption
template<typename T>
requires std::integral<T>
void bar(T);  // #1

template<typename T>
requires std::integral<T> && (sizeof(T) >= 4)
void bar(T);  // #2 —— 可能导致歧义!

// 原因:编译器把两个 requires-clause 分别视为独立的原子约束,
// 无法判断 #2 蕴含 #1

Subsumption 陷阱:只有通过具名 Concept 的逻辑组合才能建立蕴含关系。如果两个约束只是"恰好文本相同"但不通过具名 Concept 关联,编译器不会认为它们存在蕴含关系,可能导致重载歧义。

4. 约束重载

利用约束排序,我们可以为不同类型能力提供不同的实现——编译器自动选择最优版本:

#include <concepts>
#include <iostream>
#include <vector>
#include <string>
#include <ranges>

// 定义 Concept 层次
template<typename T>
concept Printable = requires(std::ostream& os, const T& val) {
    { os << val };
};

template<typename T>
concept Container = requires(const T& c) {
    { c.begin() } -> std::input_or_output_iterator;
    { c.end() } -> std::input_or_output_iterator;
    { c.size() } -> std::convertible_to<std::size_t>;
};

template<typename T>
concept StringLike =
    Container<T> &&
    std::convertible_to<T, std::string_view>;

// 重载层次 #1:通用打印(最宽松)
template<Printable T>
void print(const T& value) {
    std::cout << value << '\n';
}

// 重载层次 #2:容器打印(比 Printable 更严格)
template<Container T>
void print(const T& container) {
    std::cout << "[";
    bool first = true;
    for (const auto& elem : container) {
        if (!first) std::cout << ", ";
        std::cout << elem;
        first = false;
    }
    std::cout << "]\n";
}

// 重载层次 #3:字符串打印(蕴含 Container,最严格)
template<StringLike T>
void print(const T& str) {
    std::cout << '"' << std::string_view(str) << "\"\n";
}

int main() {
    print(42);                         // #1:Printable(int 不是 Container)
    print(std::vector{1, 2, 3});       // #2:Container(vector 不是 StringLike)
    print(std::string("hello"));       // #3:StringLike(最严格匹配)
}

这比传统的 if constexpr 或 SFINAE 方案清晰得多:

// 传统 SFINAE 方案(对比)—— 难读、难维护
template<typename T,
         std::enable_if_t</* 复杂条件 */>* = nullptr>
void print(const T&);  // 错误信息晦涩

// Concepts 方案 —— 直观、错误信息清晰
template<Container T>
void print(const T&);  // 编译错误会告诉你"T 不满足 Container"

5. Concepts 与 auto

C++20 允许在 auto 前添加 Concept 名称来约束自动推导的类型,这是简写函数模板(abbreviated function template)的核心语法:

#include <concepts>
#include <iostream>

// 约束单个参数
void process(std::integral auto x) {
    std::cout << "处理整数: " << x << '\n';
}

// 等价的完整写法:
// template<std::integral T>
// void process(T x) { ... }

// 约束多个参数——每个 auto 独立约束
void compute(std::integral auto x, std::floating_point auto y) {
    std::cout << "整数 " << x << " + 浮点 " << y
              << " = " << (x + y) << '\n';
}

// 注意:每个 constrained auto 都是独立的模板参数
// compute(1, 2) 会失败——2 不是 floating_point

// 约束返回值
std::integral auto gcd(std::integral auto a, std::integral auto b) {
    while (b != 0) {
        auto t = b;
        b = a % b;
        a = t;
    }
    return a;  // 返回值也必须满足 integral
}

// 约束 lambda
auto square = [](std::integral auto n) { return n * n; };

int main() {
    process(42);           // OK
    // process(3.14);      // 编译错误:double 不满足 integral

    compute(10, 3.14);     // OK:int + double

    auto result = gcd(48, 18);  // result 类型为 int
    std::cout << "GCD = " << result << '\n';

    std::cout << square(5) << '\n';  // 25
}

何时用简写 vs 完整形式?当函数只有一两个受约束的参数且不需要在函数体中引用类型名时,简写形式更简洁。如果需要引用模板参数类型(如声明同类型的局部变量),则需要完整的 template<Concept T> 形式。

// 简写形式无法引用类型名——需要 decltype
void foo(std::integral auto x) {
    decltype(x) copy = x;  // 需要 decltype 获取类型
}

// 完整形式可以直接使用 T
template<std::integral T>
void bar(T x) {
    T copy = x;  // 直接用 T
    std::vector<T> vec;  // 需要类型名时更方便
}

6. Concepts 与类模板

Concepts 同样适用于类模板,可以约束模板参数,也可以条件性地启用成员函数:

#include <concepts>
#include <iostream>
#include <vector>
#include <numeric>

// 约束类模板参数
template<std::regular T>  // T 必须可默认构造、可复制、可比较
class Stack {
    std::vector<T> data_;
public:
    void push(const T& value) { data_.push_back(value); }
    void push(T&& value) { data_.push_back(std::move(value)); }

    T pop() {
        T top = std::move(data_.back());
        data_.pop_back();
        return top;
    }

    bool empty() const { return data_.empty(); }
    std::size_t size() const { return data_.size(); }

    // 条件成员函数:只有 T 支持 + 运算时才存在
    T sum() const requires std::integral<T> || std::floating_point<T> {
        return std::accumulate(data_.begin(), data_.end(), T{});
    }

    // 条件成员函数:只有 T 可打印时才存在
    void print_all() const requires Printable<T> {
        for (const auto& elem : data_) {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }
};

// 使用
Stack<int> si;
si.push(10);
si.push(20);
si.sum();        // OK:int 满足 integral
si.print_all();  // OK:int 是 Printable

Stack<std::string> ss;
ss.push("hello");
// ss.sum();     // 编译错误:string 不满足 integral || floating_point
ss.print_all();  // OK:string 是 Printable

还可以通过约束来特化类模板:

// 主模板:通用实现
template<typename T>
class Formatter {
public:
    std::string format(const T& value) {
        return "unknown";
    }
};

// 特化:数值类型
template<Numeric T>
class Formatter<T> {
public:
    std::string format(T value) {
        return std::to_string(value);
    }
};

// 特化:字符串类型
template<StringLike T>
class Formatter<T> {
public:
    std::string format(const T& value) {
        return '"' + std::string(value) + '"';
    }
};

requires 在成员函数上的限制:带 requires 的成员函数不会影响类的实例化——它只在被调用时才会检查约束。这意味着你可以实例化 Stack<string>,只要不调用 sum() 就不会报错。

7. 实际设计模式:序列化库的 Concept 层次

让我们用一个完整的实际案例——序列化库——来展示如何设计 Concept 层次并利用重载决议自动分发:

#include <concepts>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>

// ============ 第一步:定义 Concept 层次 ============

// 最基础:可序列化(能转为某种字节/字符串表示)
template<typename T>
concept Serializable = requires(const T& obj) {
    { obj.serialize() } -> std::convertible_to<std::string>;
};

// 中间层:可文本序列化(能转为人类可读的文本)
template<typename T>
concept TextSerializable =
    Serializable<T> &&
    requires(const T& obj) {
        { obj.to_text() } -> std::convertible_to<std::string>;
    };

// 最严格:可 JSON 序列化
template<typename T>
concept JsonSerializable =
    TextSerializable<T> &&
    requires(const T& obj) {
        { obj.to_json() } -> std::convertible_to<std::string>;
    };

// ============ 第二步:基于约束的重载 ============

// 通用序列化:只要能 serialize() 就行
template<Serializable T>
std::string save(const T& obj) {
    std::cout << "[binary serialization]\n";
    return obj.serialize();
}

// 文本序列化:优先使用可读性更好的格式
template<TextSerializable T>
std::string save(const T& obj) {
    std::cout << "[text serialization]\n";
    return obj.to_text();
}

// JSON 序列化:最优选——结构化且可读
template<JsonSerializable T>
std::string save(const T& obj) {
    std::cout << "[JSON serialization]\n";
    return obj.to_json();
}

// ============ 第三步:实现不同层次的类型 ============

// 只支持二进制序列化
struct BinaryBlob {
    std::vector<uint8_t> data;
    std::string serialize() const {
        return std::string(data.begin(), data.end());
    }
};

// 支持文本序列化
struct LogEntry {
    std::string message;
    int level;

    std::string serialize() const {
        return message + ":" + std::to_string(level);
    }
    std::string to_text() const {
        return "[Level " + std::to_string(level) + "] " + message;
    }
};

// 支持 JSON 序列化
struct UserProfile {
    std::string name;
    int age;

    std::string serialize() const {
        return name + ":" + std::to_string(age);
    }
    std::string to_text() const {
        return name + " (age " + std::to_string(age) + ")";
    }
    std::string to_json() const {
        return R"({"name":")" + name + R"(","age":)" + std::to_string(age) + "}";
    }
};

// ============ 第四步:使用 ============

int main() {
    BinaryBlob blob{{0x48, 0x65, 0x6C, 0x6C, 0x6F}};
    LogEntry log{"Server started", 1};
    UserProfile user{"Alice", 30};

    // 编译器自动选择最严格匹配的重载
    auto r1 = save(blob);   // → [binary serialization]
    auto r2 = save(log);    // → [text serialization]
    auto r3 = save(user);   // → [JSON serialization]

    std::cout << r1 << '\n';  // Hello
    std::cout << r2 << '\n';  // [Level 1] Server started
    std::cout << r3 << '\n';  // {"name":"Alice","age":30}
}

重载决议的过程:

  1. UserProfile 满足所有三个 Concept,但 JsonSerializable 蕴含 TextSerializable(因为前者包含后者作为合取项),TextSerializable 又蕴含 Serializable。所以选最严格的 JSON 版本。
  2. LogEntry 满足 Serializable 和 TextSerializable,但不满足 JsonSerializable。在前两者中 TextSerializable 更严格,选它。
  3. BinaryBlob 只满足 Serializable,别无选择。

设计建议:构建 Concept 层次时,让更严格的 Concept 通过 && 包含更宽松的 Concept。这样编译器能自动建立蕴含关系,重载决议自然正确。避免独立定义两个有"隐含"关系但未显式组合的 Concept——编译器看不到你心中的层次。

本节要点

  • && 和 || 将 Concept 组合为更复杂的约束;优先复用标准库原子概念
  • requires requires 中第一个是约束子句,第二个是 requires 表达式;仅用于一次性约束
  • 约束排序(subsumption):如果 Concept A 包含 B 作为合取项,则 A 比 B 更受约束
  • 多个受不同约束的重载共存时,编译器自动选择约束最严格且满足的版本
  • std::integral auto x 是简写函数模板,约束与推导合一
  • 类模板可用 Concept 约束参数,成员函数可用 requires 条件启用
  • 设计实践:通过 && 显式构建 Concept 层次,让编译器的 subsumption 机制自动正确分发