Concepts 基础
C++20 引入的 Concepts 是模板编程最重要的改进之一。它让我们可以用清晰、可读的语法声明模板参数必须满足的约束条件,从根本上解决了模板错误信息难以理解的历史性痛点。
1. 为什么需要 Concepts
在 C++20 之前,约束模板参数的唯一方式是 SFINAE(Substitution Failure Is Not An Error)。SFINAE 虽然强大,但有两个致命缺点:语法晦涩、错误信息灾难。
C++17:SFINAE 时代的错误信息
假设我们写了一个只接受数值类型的加法函数:
// C++17: 用 SFINAE 约束
template<typename T,
typename = std::enable_if_t<std::is_arithmetic_v<T>>>
T add(T a, T b) {
return a + b;
}
// 当用户传入 std::string 时...
auto result = add(std::string("hello"), std::string("world"));
编译器输出(GCC 示例,已简化):
// error: no matching function for call to 'add(std::string, std::string)'
// candidate: template<class T, class> T add(T, T)
// template argument deduction/substitution failed:
// error: no type named 'type' in
// 'struct std::enable_if<false, void>'
// ... 还有 20 行关于 enable_if 内部实现的信息
C++20:Concepts 时代的错误信息
// C++20: 用 Concept 约束
template<typename T>
concept Numeric = std::is_arithmetic_v<T>;
template<Numeric T>
T add(T a, T b) {
return a + b;
}
// 同样传入 std::string...
auto result = add(std::string("hello"), std::string("world"));
编译器输出:
// error: no matching function for call to 'add(std::string, std::string)'
// note: constraints not satisfied
// note: the required expression 'std::is_arithmetic_v<T>' is not satisfied
// with T = std::basic_string<char>
// 就这么多。清晰明了。
核心价值:Concepts 不只是语法糖——它们从根本上改变了编译器理解和报告模板约束的方式。错误信息从"替换失败导致 enable_if 内部类型不存在"变成了"类型 T 不满足约束 Numeric"。
2. Concept 定义语法
Concept 本质上是一个编译期布尔值的命名。其基本语法为:
template<typename T>
concept 概念名 = 约束表达式;
基于类型特征定义
最简单的方式是直接复用现有的 type_traits:
#include <type_traits>
#include <concepts>
// 基于 type_traits 的简单 concept
template<typename T>
concept Numeric = std::is_arithmetic_v<T>;
// 组合多个 traits
template<typename T>
concept SignedNumeric = std::is_arithmetic_v<T> && std::is_signed_v<T>;
// 使用逻辑运算符
template<typename T>
concept StringLike = std::is_convertible_v<T, std::string_view>;
基于 requires 表达式定义
更强大的方式是用 requires 表达式直接检查类型是否支持特定操作:
// 检查是否可比较
template<typename T>
concept Sortable = requires(T a, T b) {
{ a < b } -> std::convertible_to<bool>;
};
// 检查是否有特定成员
template<typename T>
concept Container = requires(T c) {
typename T::value_type; // 类型要求
typename T::iterator;
{ c.begin() } -> std::input_or_output_iterator;
{ c.end() } -> std::input_or_output_iterator;
{ c.size() } -> std::integral;
};
// 检查是否可序列化为字符串
template<typename T>
concept Printable = requires(std::ostream& os, T val) {
{ os << val } -> std::same_as<std::ostream&>;
};
三种 requires 需求类型
| 需求类型 | 语法 | 检查内容 |
|---|---|---|
| 简单需求 | expr; | 表达式是否合法(不求值) |
| 类型需求 | typename T::X; | 类型是否存在 |
| 复合需求 | { expr } -> concept; | 表达式合法 + 返回类型满足约束 |
3. 使用 Concepts 约束模板
C++20 提供了四种等价的语法来约束模板参数。选择哪种取决于上下文和可读性偏好。
语法一:约束模板参数(推荐)
// 直接在 template<> 中使用 concept 名替代 typename
template<Numeric T>
T add(T a, T b) {
return a + b;
}
// 多个参数可以使用不同约束
template<Numeric T, Printable U>
void log_and_add(T val, U label) {
std::cout << label << ": " << val + val << '\n';
}
语法二:requires 子句(前置)
// requires 子句放在模板参数列表之后
template<typename T>
requires Numeric<T>
T add(T a, T b) {
return a + b;
}
// 适合复杂约束表达式
template<typename T>
requires Numeric<T> && (sizeof(T) >= 4)
T precise_add(T a, T b) {
return a + b;
}
语法三:简写函数模板(最简洁)
// 使用 concept auto 参数——编译器自动推导模板
auto add(Numeric auto a, Numeric auto b) {
return a + b;
}
// 注意:这里 a 和 b 可以是不同类型!
auto x = add(1, 2.5); // int + double = double
// 等价于:
// template<Numeric T, Numeric U>
// auto add(T a, U b) { return a + b; }
语法四:requires 子句(后置)
// requires 放在函数声明末尾
template<typename T>
T add(T a, T b) requires Numeric<T> {
return a + b;
}
// 适合成员函数和虚函数场景
class Calculator {
template<typename T>
T compute(T a, T b) requires Numeric<T>;
};
选择建议:
- 简单约束:用语法一(
template<Numeric T>),最清晰 - 自由函数 + 自动推导:用语法三(
Numeric auto),最简洁 - 复杂/组合约束:用语法二(前置
requires),约束表达式可以写多行 - 成员函数:用语法四(后置
requires),避免打断声明
4. requires 表达式详解
requires 表达式是 Concepts 的核心构建块。它在编译期检查一组操作是否对给定类型合法,返回 bool。
简单需求(Simple Requirement)
只检查表达式是否格式正确(well-formed),不求值也不检查返回类型:
template<typename T>
concept Addable = requires(T x) {
x + x; // 只检查 T 是否支持 operator+
x - x; // 只检查 T 是否支持 operator-
-x; // 只检查一元取负
};
// std::string 满足 Addable(因为 string 有 operator+)
// 但语义可能不是你想要的——这就是为什么需要更精确的约束
类型需求(Type Requirement)
检查某个类型名是否存在:
template<typename T>
concept HasValueType = requires {
typename T::value_type; // T 必须有 value_type 成员类型
typename T::iterator; // T 必须有 iterator 成员类型
typename T::size_type; // T 必须有 size_type 成员类型
};
// std::vector<int> 满足 HasValueType
// int 不满足
复合需求(Compound Requirement)
同时检查表达式合法性、返回类型和可选的 noexcept 属性:
template<typename T>
concept Sizable = requires(T c) {
// 语法: { 表达式 } noexcept(可选) -> 类型约束;
{ c.size() } noexcept -> std::integral;
// 意思:c.size() 必须:
// 1. 是合法表达式
// 2. 不抛异常
// 3. 返回类型满足 std::integral
};
template<typename T>
concept Hashable = requires(T val) {
{ std::hash<T>{}(val) } -> std::convertible_to<std::size_t>;
};
嵌套需求(Nested Requirement)
在 requires 表达式内部添加额外的编译期布尔约束:
template<typename T>
concept LargeNumeric = requires {
requires std::is_arithmetic_v<T>; // 必须是算术类型
requires sizeof(T) >= 4; // 至少 4 字节
requires !std::is_same_v<T, bool>; // 排除 bool
};
// int ✓ (算术类型, 4字节, 不是 bool)
// double ✓ (算术类型, 8字节, 不是 bool)
// char ✗ (算术类型, 但只有 1 字节)
// bool ✗ (算术类型, 但被显式排除)
注意区分两种 requires:
requires子句(clause):约束模板的语法,放在模板声明中requires表达式(expression):产生 bool 值的编译期表达式
两者可以组合:template<typename T> requires requires(T x) { x + x; }——第一个 requires 是子句,第二个是表达式。这被戏称为"requires requires"模式,虽然合法但应避免使用,请提取为命名 concept。
5. 标准概念库 (<concepts>)
C++20 在 <concepts> 和 <iterator> 头文件中提供了大量预定义 Concepts。优先使用标准概念,避免重复造轮子。
核心语言概念
| Concept | 含义 | 示例满足类型 |
|---|---|---|
std::same_as<T, U> | T 和 U 是相同类型 | same_as<int, int> |
std::derived_from<D, B> | D 公开继承自 B | 子类与基类 |
std::convertible_to<From, To> | From 可隐式转换为 To | int → double |
std::integral | 整数类型 | int, long, char |
std::floating_point | 浮点类型 | float, double |
std::signed_integral | 有符号整数 | int, long |
std::unsigned_integral | 无符号整数 | unsigned, size_t |
比较概念
| Concept | 含义 |
|---|---|
std::equality_comparable | 支持 == 和 != |
std::totally_ordered | 支持 < > <= >= 和相等比较 |
std::three_way_comparable | 支持 <=> |
对象概念
| Concept | 含义 |
|---|---|
std::movable | 可移动构造 + 可移动赋值 |
std::copyable | 可拷贝 + 可移动 |
std::semiregular | 可拷贝 + 可默认构造 |
std::regular | semiregular + equality_comparable |
可调用概念
| Concept | 含义 |
|---|---|
std::invocable<F, Args...> | F 可用 Args... 调用 |
std::predicate<F, Args...> | invocable 且返回 bool |
std::relation<F, T, U> | 二元关系谓词 |
Ranges 概念(<ranges>)
#include <ranges>
// 常用 range concepts
template<std::ranges::range R>
void process(R&& rng); // 任何 range
template<std::ranges::input_range R>
void read_all(R&& rng); // 可读遍历
template<std::ranges::random_access_range R>
void sort_it(R&& rng); // 支持随机访问
template<std::ranges::sized_range R>
void reserve_and_copy(R&& rng); // 可 O(1) 获取大小
6. Concepts vs SFINAE 对比
| 维度 | SFINAE (C++11/14/17) | Concepts (C++20) |
|---|---|---|
| 可读性 | enable_if_t<is_arithmetic_v<T>> |
Numeric T |
| 错误信息 | 几十行模板展开 | 1-3 行:哪个约束不满足 |
| 组合约束 | 嵌套 enable_if + conjunction | && / || 直接组合 |
| 重载决议 | 不参与排序 | 更特化的 concept 优先匹配 |
| 文档价值 | 需要额外注释 | concept 名本身就是文档 |
| 学习曲线 | 极陡峭 | 平缓,接近自然语言 |
// SFINAE 实现:只接受容器类型
template<typename C,
typename = std::enable_if_t<
std::is_same_v<
decltype(std::declval<C>().begin()),
typename C::iterator
>
>>
void print_all(const C& container) {
for (auto&& elem : container)
std::cout << elem << ' ';
}
// Concepts 实现:清晰简洁
void print_all(const std::ranges::range auto& container) {
for (auto&& elem : container)
std::cout << elem << ' ';
}
实践原则:所有新代码都应使用 Concepts。SFINAE 仅在维护旧代码或需要支持 C++17 编译器时使用。
7. 实用例子
例一:通用容器打印器
#include <iostream>
#include <concepts>
#include <ranges>
#include <vector>
#include <list>
#include <map>
// 定义 Printable concept
template<typename T>
concept Printable = requires(std::ostream& os, T val) {
{ os << val } -> std::same_as<std::ostream&>;
};
// 打印任何元素可输出的 range
void print_range(std::ranges::range auto const& rng)
requires Printable<std::ranges::range_value_t<
decltype(rng)>>
{
std::cout << "[";
bool first = true;
for (auto const& elem : rng) {
if (!first) std::cout << ", ";
std::cout << elem;
first = false;
}
std::cout << "]\n";
}
int main() {
std::vector<int> v{1, 2, 3, 4, 5};
std::list<double> l{1.1, 2.2, 3.3};
print_range(v); // [1, 2, 3, 4, 5]
print_range(l); // [1.1, 2.2, 3.3]
}
例二:受约束的数值累加
#include <concepts>
#include <ranges>
#include <numeric>
#include <vector>
// Concept: 可以相加的数值类型
template<typename T>
concept Summable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
} && std::default_initializable<T>;
// 只接受元素可累加的 range
template<std::ranges::input_range R>
requires Summable<std::ranges::range_value_t<R>>
auto accumulate(R&& rng) {
using T = std::ranges::range_value_t<R>;
T sum{};
for (auto const& val : rng) {
sum = sum + val;
}
return sum;
}
int main() {
std::vector<int> nums{1, 2, 3, 4, 5};
auto total = accumulate(nums); // 15
// std::vector<std::mutex> 会被拒绝——
// std::mutex 不可加,约束清晰地告知原因
}
例三:Hashable concept
#include <concepts>
#include <functional>
#include <string>
#include <unordered_set>
// 检查类型是否可以作为 unordered 容器的键
template<typename T>
concept Hashable = requires(T val) {
{ std::hash<T>{}(val) } -> std::convertible_to<std::size_t>;
} && std::equality_comparable<T>;
// 只接受可哈希的类型
template<Hashable Key>
class UniqueStore {
std::unordered_set<Key> data_;
public:
void insert(Key const& key) { data_.insert(key); }
bool contains(Key const& key) const { return data_.contains(key); }
std::size_t size() const { return data_.size(); }
};
int main() {
UniqueStore<std::string> store; // OK: string 可哈希
store.insert("hello");
store.insert("world");
store.insert("hello"); // 重复,不插入
// store.size() == 2
// UniqueStore<std::vector<int>> bad; // 编译错误!
// error: constraints not satisfied: Hashable<std::vector<int>>
// note: 'std::hash<std::vector<int>>{}(val)' is not a valid expression
}
本章小结
- Concept = 命名的编译期类型约束,用
concept关键字定义 - 四种约束语法任选其一:
template<C T>、前置requires、C auto、后置requires requires表达式支持简单/类型/复合/嵌套四种需求- 标准库
<concepts>提供丰富的预定义 concepts:integral、floating_point、invocable等 - 相比 SFINAE,Concepts 的错误信息、可读性、可组合性全方位碾压
- 新代码一律使用 Concepts,SFINAE 仅用于旧代码兼容