标准概念库
什么是标准概念库
C++20 在 <concepts> 头文件中提供了一套预定义的标准概念,覆盖了类型关系、算术类型、生命周期管理、对象语义、可调用类型等常见的类型约束需求。这些概念是标准库和用户代码中最常用的构建块——你可以直接拿来用,也可以基于它们组合出更复杂的自定义概念。
标准概念库的设计原则是:概念不仅描述语法要求("这个类型有哪些操作"),还隐含语义要求("这些操作应该怎么表现")。比如 std::regular 不仅要求类型可以复制和比较,还隐含"复制出来的对象和原来的相等"这样的语义约束。
头文件
#include <concepts>标准概念分类总览
核心语言概念
| 概念 | 含义 |
|---|---|
std::same_as<T, U> | T 和 U 是同一类型 |
std::derived_from<Derived, Base> | Derived 公有继承自 Base |
std::convertible_to<From, To> | From 可以隐式转换为 To |
std::common_reference_with<T, U> | T 和 U 有公共引用类型 |
std::common_with<T, U> | T 和 U 有公共类型 |
算术类型概念
| 概念 | 含义 |
|---|---|
std::integral<T> | T 是整数类型(含 bool、char) |
std::signed_integral<T> | T 是有符号整数类型 |
std::unsigned_integral<T> | T 是无符号整数类型 |
std::floating_point<T> | T 是浮点类型 |
生命周期概念
| 概念 | 含义 |
|---|---|
std::destructible<T> | T 可以被析构 |
std::constructible_from<T, Args...> | T 可以用 Args... 构造 |
std::default_initializable<T> | T 可以默认构造 |
std::move_constructible<T> | T 可以移动构造 |
std::copy_constructible<T> | T 可以复制构造 |
赋值概念
| 概念 | 含义 |
|---|---|
std::assignable_from<LHS, RHS> | 可以把 RHS 赋值给 LHS |
std::swappable<T> | T 的对象可以交换 |
std::swappable_with<T, U> | T 和 U 的对象可以互相交换 |
比较概念
| 概念 | 含义 |
|---|---|
std::equality_comparable<T> | T 支持 == 和 != |
std::equality_comparable_with<T, U> | T 和 U 之间可以比较相等 |
std::totally_ordered<T> | T 支持全序比较(<、>、<=、>=、==、!=) |
std::totally_ordered_with<T, U> | T 和 U 之间支持全序比较 |
对象概念
| 概念 | 含义 | 包含的要求 |
|---|---|---|
std::movable<T> | 可移动的对象类型 | 对象类型 + 移动构造 + 移动赋值 + 可交换 |
std::copyable<T> | 可复制的对象类型 | movable + 复制构造 + 复制赋值 |
std::semiregular<T> | 半正则类型 | copyable + 默认构造 |
std::regular<T> | 正则类型 | semiregular + equality_comparable |
可调用概念
| 概念 | 含义 |
|---|---|
std::invocable<F, Args...> | F 可以用 Args... 调用 |
std::regular_invocable<F, Args...> | F 可以用 Args... 调用(不修改状态) |
std::predicate<F, Args...> | F 是返回 bool 的谓词 |
std::relation<R, T, U> | R 是 T 和 U 之间的二元关系 |
std::equivalence_relation<R, T, U> | R 是等价关系 |
std::strict_weak_order<R, T, U> | R 是严格弱序 |
基本示例
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <functional>
#include <memory>
// ============================
// 示例1:算术类型概念
// ============================
// 只接受整数类型
template<std::integral T>
T gcd(T a, T b) {
while (b != 0) {
T temp = b;
b = a % b;
a = temp;
}
return a;
}
// 只接受浮点类型
template<std::floating_point T>
bool nearly_equal(T a, T b, T epsilon = T(1e-6)) {
return (a - b < epsilon) && (b - a < epsilon);
}
// 有符号整数
template<std::signed_integral T>
T safe_abs(T value) {
return value < 0 ? -value : value;
}
void arithmetic_demo() {
std::cout << "gcd(12, 8) = " << gcd(12, 8) << std::endl; // 4
std::cout << "gcd(100, 75) = " << gcd(100, 75) << std::endl; // 25
std::cout << std::boolalpha;
std::cout << "nearly_equal(0.1+0.2, 0.3) = "
<< nearly_equal(0.1 + 0.2, 0.3) << std::endl; // true
std::cout << "safe_abs(-42) = " << safe_abs(-42) << std::endl; // 42
// gcd(3.14, 2.0); // 编译错误:double 不满足 integral
// safe_abs(42u); // 编译错误:unsigned int 不满足 signed_integral
}
// ============================
// 示例2:类型关系概念
// ============================
struct Animal { virtual ~Animal() = default; };
struct Dog : public Animal {};
struct Cat : public Animal {};
// 要求 T 继承自 Animal
template<std::derived_from<Animal> T>
void feed(const T& pet) {
std::cout << "喂食动物" << std::endl;
}
// 要求 From 可以转换为 To
template<typename From, typename To>
requires std::convertible_to<From, To>
To convert(From value) {
return static_cast<To>(value);
}
void relationship_demo() {
Dog dog;
Cat cat;
feed(dog); // Dog 继承自 Animal,通过
feed(cat); // Cat 继承自 Animal,通过
// feed(42); // int 不继承自 Animal,编译错误
double d = convert<int, double>(42);
std::cout << "convert<int, double>(42) = " << d << std::endl;
}
// ============================
// 示例3:对象概念层级
// ============================
// std::regular 是最严格的对象概念:
// 可默认构造 + 可复制 + 可移动 + 可交换 + 支持 ==
template<std::regular T>
class ValueWrapper {
T value_;
public:
ValueWrapper() = default;
explicit ValueWrapper(T v) : value_(std::move(v)) {}
const T& get() const { return value_; }
bool operator==(const ValueWrapper&) const = default;
};
// std::movable 是最宽松的对象概念
template<std::movable T>
class MoveOnlyWrapper {
T value_;
public:
explicit MoveOnlyWrapper(T v) : value_(std::move(v)) {}
const T& get() const { return value_; }
};
void object_concept_demo() {
// int 满足 regular
ValueWrapper<int> w1(42);
ValueWrapper<int> w2(42);
std::cout << "w1 == w2: " << std::boolalpha << (w1 == w2) << std::endl;
// unique_ptr 只满足 movable,不满足 copyable
MoveOnlyWrapper<std::unique_ptr<int>> mw(std::make_unique<int>(99));
std::cout << "move-only wrapper: " << *mw.get() << std::endl;
// 以下编译错误:unique_ptr 不满足 regular
// ValueWrapper<std::unique_ptr<int>> fail;
}
// ============================
// 示例4:可调用概念
// ============================
// 要求 F 是可以用 int, int 调用的函数
template<std::invocable<int, int> F>
int apply_binary(F func, int a, int b) {
return func(a, b);
}
// 要求 F 是返回 bool 的谓词
template<typename T, std::predicate<T> F>
std::vector<T> filter(const std::vector<T>& data, F pred) {
std::vector<T> result;
for (const auto& item : data) {
if (pred(item)) {
result.push_back(item);
}
}
return result;
}
void callable_demo() {
// 普通函数
auto result = apply_binary([](int a, int b) { return a + b; }, 3, 4);
std::cout << "apply_binary(+, 3, 4) = " << result << std::endl;
// 谓词过滤
std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto evens = filter(nums, [](int n) { return n % 2 == 0; });
std::cout << "偶数: ";
for (int n : evens) std::cout << n << " ";
std::cout << std::endl;
}
// ============================
// 示例5:比较概念
// ============================
template<std::equality_comparable T>
bool contains(const std::vector<T>& vec, const T& target) {
for (const auto& item : vec) {
if (item == target) return true;
}
return false;
}
template<std::totally_ordered T>
T find_max(const std::vector<T>& vec) {
T max_val = vec[0];
for (std::size_t i = 1; i < vec.size(); ++i) {
if (vec[i] > max_val) max_val = vec[i];
}
return max_val;
}
void comparison_demo() {
std::vector<int> nums{3, 1, 4, 1, 5, 9};
std::cout << "contains 5: " << std::boolalpha << contains(nums, 5) << std::endl;
std::cout << "max: " << find_max(nums) << std::endl;
std::vector<std::string> words{"hello", "world", "cpp"};
std::cout << "max word: " << find_max(words) << std::endl;
}
int main() {
std::cout << "=== 算术类型 ===" << std::endl;
arithmetic_demo();
std::cout << "\n=== 类型关系 ===" << std::endl;
relationship_demo();
std::cout << "\n=== 对象概念 ===" << std::endl;
object_concept_demo();
std::cout << "\n=== 可调用 ===" << std::endl;
callable_demo();
std::cout << "\n=== 比较 ===" << std::endl;
comparison_demo();
return 0;
}对象概念的层级关系
标准库的四个对象概念形成一个由宽到严的层级:
movable ← 最基础:对象类型 + 移动构造 + 移动赋值 + 可交换
↑
copyable ← movable + 复制构造 + 复制赋值
↑
semiregular ← copyable + 默认构造
↑
regular ← semiregular + 支持 ==(equality_comparable)| 类型示例 | movable | copyable | semiregular | regular |
|---|---|---|---|---|
int | 满足 | 满足 | 满足 | 满足 |
std::string | 满足 | 满足 | 满足 | 满足 |
std::unique_ptr | 满足 | 不满足 | 不满足 | 不满足 |
std::vector<int> | 满足 | 满足 | 满足 | 满足 |
适用场景
- 约束泛型函数的参数类型(最常见用法)
- 在自定义概念中组合使用标准概念
- 为容器和算法定义类型要求
- 替代
<type_traits>中的类型判断(语法更简洁) - 模板函数重载决议——让编译器根据概念选择最匹配的版本
常见问题
std::integral 包含 bool 和 char 吗?
包含。std::integral 等价于 std::is_integral_v<T>,它包括 bool、char、signed char、unsigned char、wchar_t、char8_t、char16_t、char32_t 以及所有整数类型。如果你只想要"数学意义上的整数",需要自己排除 bool 和字符类型。
same_as 和 is_same_v 有什么区别?
语义一样,但 same_as 是概念,可以用在约束中;is_same_v 是类型特征变量模板,不能直接用在概念的约束语法中。另外 same_as<T, U> 是对称的(same_as<T, U> 包含 same_as<U, T>),is_same_v 本来也是对称的但在某些模板偏序场景下表现不同。
invocable 和 regular_invocable 有什么区别?
语法上没有区别——它们的约束条件相同。区别是语义上的:regular_invocable 额外要求调用不会修改可调用对象或参数的状态(类似数学函数)。编译器不检查这个语义约束,它是对使用者的一种文档化约定。
standard concepts 在 <concepts> 之外还有吗?
有。<iterator> 中定义了迭代器相关概念(如 std::input_iterator、std::random_access_iterator),<ranges> 中定义了范围概念(如 std::ranges::range、std::ranges::view)。
注意事项
- 标准概念既有语法要求也有语义要求,编译器只检查语法部分
std::integral包含 bool 和字符类型,使用时注意是否需要排除- 概念之间有包含关系(subsumption),影响重载决议
- 组合标准概念时用
&&和||,不要在概念定义中用!(取反不参与包含关系) - 优先使用标准概念,不要重复造轮子
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 10.0 |
| Clang | 10.0 |
| MSVC | 19.26 (VS 2019 16.6) |
总结
标准概念库(<concepts>)提供了约 30 个预定义概念,覆盖了类型关系(same_as、derived_from、convertible_to)、算术类型(integral、floating_point)、生命周期(constructible_from、move_constructible)、对象语义(movable、copyable、semiregular、regular)、比较(equality_comparable、totally_ordered)和可调用(invocable、predicate)等方面。这些概念是模板约束的基础构建块,可以直接使用,也可以组合成更复杂的自定义概念。使用标准概念代替手写类型特征判断,代码更简洁、错误信息更清晰、重载决议更智能。