概念(Concepts)基础定义
什么是概念
概念(Concept)是 C++20 引入的一种语言特性,用来对模板参数施加约束。简单来说,概念就是一个编译期的布尔谓词——它描述了一个类型需要满足的条件,比如"必须是整数类型""必须支持加法运算""必须可以被哈希"等。
在 C++20 之前,模板几乎什么类型都接受,只有在模板实例化时(也就是编译器展开模板代码时)才会发现类型不匹配,然后产生一大堆难以理解的错误信息。概念改变了这种状况:它在模板实例化之前就检查类型是否满足要求,如果不满足,编译器会给出清晰的错误信息——"类型 X 不满足概念 Y"。
概念的定义语法
template<模板参数列表>
concept 概念名 = 约束表达式;约束表达式是一个编译期求值为 bool 的表达式。它可以使用类型特征(type_traits)、requires 表达式、其他概念的组合等。
#include <concepts>
#include <type_traits>
// 用 type_traits 定义概念
template<typename T>
concept Integral = std::is_integral_v<T>;
// 用 requires 表达式定义概念
template<typename T>
concept Addable = requires(T a, T b) {
a + b; // 要求 a + b 是合法表达式
};
// 组合多个条件
template<typename T>
concept SignedInteger = std::is_integral_v<T> && std::is_signed_v<T>;
// 用已有概念组合
template<typename T>
concept Number = std::integral<T> || std::floating_point<T>;使用概念的四种语法
概念定义好之后,有四种方式把它应用到模板上:
#include <iostream>
#include <concepts>
// 定义一个概念
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
// ============================
// 方式1:requires 子句(最明确)
// ============================
template<typename T>
requires Numeric<T>
T add_v1(T a, T b) {
return a + b;
}
// ============================
// 方式2:概念作为模板参数约束
// ============================
template<Numeric T>
T add_v2(T a, T b) {
return a + b;
}
// ============================
// 方式3:尾置 requires 子句
// ============================
template<typename T>
T add_v3(T a, T b) requires Numeric<T> {
return a + b;
}
// ============================
// 方式4:简写形式(约束 auto)
// ============================
auto add_v4(Numeric auto a, Numeric auto b) {
return a + b;
}这四种写法的效果完全一样,选择哪种取决于个人偏好和代码场景。
基本示例
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <type_traits>
// ============================
// 示例1:基本概念定义与使用
// ============================
// 定义:类型必须支持输出到 ostream
template<typename T>
concept Printable = requires(std::ostream& os, T value) {
os << value; // 要求 << 运算符存在
};
// 使用概念约束模板函数
template<Printable T>
void print(const T& value) {
std::cout << value << std::endl;
}
void basic_concept_demo() {
print(42); // int 满足 Printable
print(3.14); // double 满足 Printable
print("hello"); // const char* 满足 Printable
print(std::string("world")); // string 满足 Printable
// 以下编译错误:vector<int> 不满足 Printable
// print(std::vector<int>{1, 2, 3});
}
// ============================
// 示例2:概念给出清晰的错误信息
// ============================
template<typename T>
concept Hashable = requires(T a) {
{ std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};
template<Hashable T>
std::size_t get_hash(const T& value) {
return std::hash<T>{}(value);
}
void error_message_demo() {
// 编译通过:int 和 string 都有 std::hash 特化
std::cout << "hash(42) = " << get_hash(42) << std::endl;
std::cout << "hash(\"hi\") = " << get_hash(std::string("hi")) << std::endl;
// 编译错误(清晰提示):
// error: 'vector<int>' does not satisfy 'Hashable'
// get_hash(std::vector<int>{1, 2});
}
// ============================
// 示例3:概念的组合(与、或)
// ============================
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
template<typename T>
concept Comparable = requires(T a, T b) {
{ a < b } -> std::convertible_to<bool>;
{ a > b } -> std::convertible_to<bool>;
{ a == b } -> std::convertible_to<bool>;
};
// 组合两个概念
template<typename T>
concept SortableNumber = Arithmetic<T> && Comparable<T>;
template<SortableNumber T>
T clamp_value(T value, T low, T high) {
if (value < low) return low;
if (value > high) return high;
return value;
}
void combination_demo() {
std::cout << "clamp(15, 0, 10) = " << clamp_value(15, 0, 10) << std::endl;
std::cout << "clamp(3.5, 1.0, 5.0) = " << clamp_value(3.5, 1.0, 5.0) << std::endl;
}
// ============================
// 示例4:约束 auto 变量
// ============================
void constrained_auto_demo() {
// 用概念约束 auto 变量
std::integral auto x = 42; // 只接受整数类型
std::floating_point auto y = 3.14; // 只接受浮点类型
// 以下编译错误:
// std::integral auto z = 3.14; // double 不满足 integral
std::cout << "x = " << x << ", y = " << y << std::endl;
}
// ============================
// 示例5:概念用于类模板
// ============================
template<typename T>
concept DefaultConstructible = std::is_default_constructible_v<T>;
template<typename T>
concept Copyable = std::copyable<T>;
// 类模板约束
template<DefaultConstructible T>
class Container {
std::vector<T> data_;
public:
void add(const T& item) {
data_.push_back(item);
}
std::size_t size() const {
return data_.size();
}
};
void class_template_demo() {
Container<int> c1;
c1.add(1);
c1.add(2);
std::cout << "容器大小: " << c1.size() << std::endl;
Container<std::string> c2;
c2.add("hello");
std::cout << "字符串容器大小: " << c2.size() << std::endl;
}
int main() {
std::cout << "=== 基本概念 ===" << std::endl;
basic_concept_demo();
std::cout << "\n=== 错误信息 ===" << std::endl;
error_message_demo();
std::cout << "\n=== 概念组合 ===" << std::endl;
combination_demo();
std::cout << "\n=== 约束 auto ===" << std::endl;
constrained_auto_demo();
std::cout << "\n=== 类模板 ===" << std::endl;
class_template_demo();
return 0;
}概念的本质
概念在本质上就是一个编译期的布尔值模板。以下两种写法是等价的:
// 概念定义
template<typename T>
concept Integral = std::is_integral_v<T>;
// 等价的变量模板(但不能用作约束)
template<typename T>
constexpr bool IsIntegral = std::is_integral_v<T>;区别在于概念可以用在约束语法中(requires 子句、模板参数约束、简写模板等),而普通的 constexpr bool 变量模板不行。概念也参与重载决议的偏序规则(更具体的概念优先)。
概念 vs 传统模板约束
| 方面 | 概念(C++20) | SFINAE(C++11/14) | static_assert(C++11) |
|---|---|---|---|
| 错误信息 | 清晰("不满足概念 X") | 晦涩(大量模板展开错误) | 自定义消息但在实例化后 |
| 参与重载决议 | 是 | 是 | 否(直接编译失败) |
| 可读性 | 好 | 差 | 中等 |
| 可组合性 | 强(&&、||) | 弱 | 无 |
| 检查时机 | 模板实例化前 | 模板参数替换时 | 模板实例化后 |
适用场景
- 对模板参数施加类型约束(替代 SFINAE 和
enable_if) - 改善模板实例化失败时的编译错误信息
- 函数模板重载:根据不同概念选择不同实现
- 类模板的条件成员函数
- 泛型库的接口设计——用概念明确描述类型要求
常见问题
概念可以继承或特化吗?
不能。概念不是类,不能继承;也不能像模板那样特化。但概念可以用其他概念来组合定义,这在效果上类似"继承"。
概念可以是递归的吗?
不能。概念定义中不能直接或间接引用自己。
概念可以作为函数参数或返回值吗?
概念本身不是类型,不能作为函数参数或返回值。但可以用概念约束的 auto(如 std::integral auto)作为参数或返回类型。
概念只能定义在命名空间作用域吗?
是的。概念必须在命名空间作用域定义,不能在函数内或类内定义。
注意事项
- 概念必须定义在命名空间作用域,不能在函数内或类内
- 概念不能递归定义
- 概念不能被特化或约束
- 概念的约束表达式必须是编译期常量
<concepts>头文件提供了标准库预定义的概念- 概念的
&&和||有特殊的"包含"语义,影响重载决议
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 10.0 |
| Clang | 10.0 |
| MSVC | 19.26 (VS 2019 16.6) |
总结
概念是 C++20 对模板编程最重要的改进之一。它让你可以用简洁的语法描述模板参数必须满足的条件,在编译早期就检测到类型不匹配,给出清晰的错误信息。概念的定义方式很灵活——可以基于类型特征、requires 表达式、或者其他概念的组合。使用方式也有四种(requires 子句、模板参数约束、尾置 requires、简写 auto),覆盖了各种代码风格偏好。概念还参与重载决议,让编译器能根据类型的不同特征自动选择最匹配的函数版本。