约束组合与重载决议
上一节我们学会了定义和使用单个 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}
}
重载决议的过程:
UserProfile满足所有三个 Concept,但JsonSerializable蕴含TextSerializable(因为前者包含后者作为合取项),TextSerializable又蕴含Serializable。所以选最严格的 JSON 版本。LogEntry满足Serializable和TextSerializable,但不满足JsonSerializable。在前两者中TextSerializable更严格,选它。BinaryBlob只满足Serializable,别无选择。
设计建议:构建 Concept 层次时,让更严格的 Concept 通过 && 包含更宽松的 Concept。这样编译器能自动建立蕴含关系,重载决议自然正确。避免独立定义两个有"隐含"关系但未显式组合的 Concept——编译器看不到你心中的层次。
本节要点
&&和||将 Concept 组合为更复杂的约束;优先复用标准库原子概念requires requires中第一个是约束子句,第二个是 requires 表达式;仅用于一次性约束- 约束排序(subsumption):如果 Concept A 包含 B 作为合取项,则 A 比 B 更受约束
- 多个受不同约束的重载共存时,编译器自动选择约束最严格且满足的版本
std::integral auto x是简写函数模板,约束与推导合一- 类模板可用 Concept 约束参数,成员函数可用
requires条件启用 - 设计实践:通过
&&显式构建 Concept 层次,让编译器的 subsumption 机制自动正确分发