自定义概念定义
为什么需要自定义概念
标准库提供的概念覆盖了通用的类型分类(整数、浮点、可复制、可比较等),但实际项目中你常常需要更具体的约束——比如"类型必须有 serialize() 方法""类型必须同时支持加法和乘法""类型必须是一个容器并且元素类型是整数"等。这些需求需要你自己定义概念。
自定义概念的核心思路:用标准概念、类型特征和 requires 表达式作为构建块,通过逻辑组合拼出你需要的约束条件。
定义语法
template<模板参数列表>
concept 概念名 = 约束表达式;约束表达式可以是以下几种形式或它们的组合:
- 标准概念或其他自定义概念
std::is_xxx_v<T>等类型特征requires表达式- 用
&&和||组合的复合条件
基本示例
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <type_traits>
#include <cmath>
// ============================
// 示例1:基于类型特征定义概念
// ============================
// 算术类型(整数或浮点)
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
// 枚举类型
template<typename T>
concept Enumeration = std::is_enum_v<T>;
// 指针类型
template<typename T>
concept Pointer = std::is_pointer_v<T>;
// 非引用类型
template<typename T>
concept NonReference = !std::is_reference_v<T>;
template<Arithmetic T>
T multiply(T a, T b) {
return a * b;
}
void type_trait_concept_demo() {
std::cout << multiply(3, 4) << std::endl; // 12
std::cout << multiply(2.5, 3.0) << std::endl; // 7.5
// multiply(std::string("a"), std::string("b")); // 编译错误
}
// ============================
// 示例2:基于 requires 表达式定义概念
// ============================
// 可序列化:要求有 serialize() 和 deserialize() 方法
template<typename T>
concept Serializable = requires(T obj, std::string data) {
{ obj.serialize() } -> std::convertible_to<std::string>;
{ T::deserialize(data) } -> std::same_as<T>;
};
// 可打印:要求可以用 << 输出到 ostream
template<typename T>
concept Printable = requires(std::ostream& os, const T& value) {
{ os << value } -> std::same_as<std::ostream&>;
};
// 容器:要求有 begin/end/size/push_back
template<typename T>
concept PushBackContainer = requires(T c, typename T::value_type v) {
typename T::value_type;
typename T::iterator;
{ c.begin() } -> std::same_as<typename T::iterator>;
{ c.end() } -> std::same_as<typename T::iterator>;
{ c.size() } -> std::convertible_to<std::size_t>;
c.push_back(v);
};
// 测试 Serializable
struct Config {
std::string name;
int value;
std::string serialize() const {
return name + "=" + std::to_string(value);
}
static Config deserialize(const std::string& data) {
auto pos = data.find('=');
return Config{data.substr(0, pos), std::stoi(data.substr(pos + 1))};
}
};
template<Serializable T>
void save(const T& obj) {
std::string data = obj.serialize();
std::cout << "保存: " << data << std::endl;
}
void requires_concept_demo() {
Config cfg{"timeout", 30};
save(cfg); // Config 满足 Serializable
// save(42); // int 不满足 Serializable,编译错误
}
// ============================
// 示例3:组合已有概念
// ============================
// 数值类型:整数或浮点
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
// 有符号数值:有符号整数或浮点
template<typename T>
concept SignedNumeric = (std::integral<T> && std::is_signed_v<T>)
|| std::floating_point<T>;
// 可排序的容器:是容器 + 元素支持全序比较
template<typename T>
concept SortableContainer = PushBackContainer<T>
&& std::totally_ordered<typename T::value_type>;
// 正则数值:是数值 + 支持相等比较 + 可默认构造
template<typename T>
concept RegularNumeric = Numeric<T>
&& std::equality_comparable<T>
&& std::default_initializable<T>;
template<SignedNumeric T>
T absolute(T value) {
return value < T(0) ? -value : value;
}
void composition_demo() {
std::cout << absolute(-42) << std::endl; // 42
std::cout << absolute(-3.14) << std::endl; // 3.14
// absolute(42u); // unsigned int 不满足 SignedNumeric,编译错误
}
// ============================
// 示例4:多参数概念
// ============================
// 两个类型可以相加,结果可以转换为 Result
template<typename T, typename U, typename Result = T>
concept AddableTo = requires(T a, U b) {
{ a + b } -> std::convertible_to<Result>;
};
// 两个类型之间可以互相转换
template<typename From, typename To>
concept BidirectionallyConvertible =
std::convertible_to<From, To> && std::convertible_to<To, From>;
template<typename T, typename U>
requires AddableTo<T, U>
auto safe_add(T a, U b) {
return a + b;
}
void multi_param_demo() {
std::cout << safe_add(3, 4.5) << std::endl; // 7.5
std::cout << safe_add(std::string("hi "), std::string("there")) << std::endl;
}
// ============================
// 示例5:用概念约束类的成员函数
// ============================
template<typename T>
class SmartContainer {
std::vector<T> data_;
public:
void add(const T& item) {
data_.push_back(item);
}
// 只有 T 支持 << 时才存在 print()
void print() const requires Printable<T> {
for (const auto& item : data_) {
std::cout << item << " ";
}
std::cout << std::endl;
}
// 只有 T 支持全序比较时才存在 sort()
void sort() requires std::totally_ordered<T> {
std::sort(data_.begin(), data_.end());
}
// 只有 T 是算术类型时才存在 sum()
T sum() const requires Arithmetic<T> {
T total = T(0);
for (const auto& item : data_) {
total += item;
}
return total;
}
std::size_t size() const { return data_.size(); }
};
void conditional_member_demo() {
SmartContainer<int> ic;
ic.add(3);
ic.add(1);
ic.add(4);
ic.sort(); // int 支持比较,sort() 存在
ic.print(); // int 支持 <<,print() 存在
std::cout << "总和: " << ic.sum() << std::endl; // int 是算术类型
SmartContainer<std::string> sc;
sc.add("hello");
sc.add("world");
sc.print(); // string 支持 <<
sc.sort(); // string 支持比较
// sc.sum(); // string 不是算术类型,sum() 不存在,编译错误
}
int main() {
std::cout << "=== 类型特征概念 ===" << std::endl;
type_trait_concept_demo();
std::cout << "\n=== requires 概念 ===" << std::endl;
requires_concept_demo();
std::cout << "\n=== 组合概念 ===" << std::endl;
composition_demo();
std::cout << "\n=== 多参数概念 ===" << std::endl;
multi_param_demo();
std::cout << "\n=== 条件成员函数 ===" << std::endl;
conditional_member_demo();
return 0;
}自定义概念的设计模式
接口概念
描述类型必须提供的方法集合,类似 Java/C# 的接口:
// 要求类型实现"可绘制"接口
template<typename T>
concept Drawable = requires(T obj, int x, int y) {
obj.draw();
obj.move(x, y);
{ obj.visible() } -> std::convertible_to<bool>;
};语义概念
基于标准概念组合,表达更高层的语义:
// "值类型":可以复制、比较、哈希
template<typename T>
concept ValueType = std::regular<T> && requires(T a) {
{ std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};层次化概念
从简单到复杂逐层构建:
template<typename T>
concept HasSize = requires(T c) {
{ c.size() } -> std::convertible_to<std::size_t>;
};
template<typename T>
concept Iterable = requires(T c) {
c.begin();
c.end();
};
template<typename T>
concept SizedIterable = HasSize<T> && Iterable<T>;
template<typename T>
concept ResizableContainer = SizedIterable<T> && requires(T c, std::size_t n) {
c.resize(n);
c.clear();
{ c.empty() } -> std::convertible_to<bool>;
};适用场景
- 定义库的公共 API 对类型的要求
- 为泛型数据结构约束元素类型
- 条件性地启用或禁用类模板的成员函数
- 替代 SFINAE 和
enable_if来进行编译时类型分派 - 在大型项目中用概念文档化类型的接口约定
常见问题
自定义概念应该放在哪里?
概念必须定义在命名空间作用域。通常和使用它们的模板放在同一个头文件中,或者集中定义在一个 concepts.h 头文件中供多处引用。
概念的名字用什么风格?
标准库用小写下划线(same_as、totally_ordered)。很多项目用大驼峰(Serializable、Drawable)来区分自定义概念和标准概念。关键是团队保持一致。
概念可以用 ! 取反吗?
可以在约束表达式中用 !,但取反后的概念不参与包含(subsumption)关系。也就是说,!ConceptA 在重载决议中不会被认为比 ConceptB 更具体或更通用。
概念定义中可以用 constexpr 函数吗?
可以。任何编译期求值为 bool 的表达式都可以作为概念的约束条件,包括 constexpr 函数调用。
注意事项
- 概念应该表达有意义的语义分类,而不只是语法检查
- 优先组合标准概念,不要从头写已有的约束
- 避免定义过于宽泛或过于狭窄的概念
- 概念不能递归定义
- 概念不能特化
- 用
&&组合的概念比单个概念更"具体",会在重载决议中优先匹配 - 用
requires约束类的成员函数时,不满足约束的成员函数会从类中"消失"(SFINAE 效果)
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 10.0 |
| Clang | 10.0 |
| MSVC | 19.26 (VS 2019 16.6) |
总结
自定义概念让你可以为自己的项目定义精确的类型约束。定义方式很灵活:可以基于类型特征(std::is_xxx_v)、requires 表达式、标准概念的组合,或者三者的混合。设计概念时应该表达有意义的语义分类("可序列化""可绘制""值类型"),而不只是机械地列举语法要求。概念还可以分层构建——从基础概念组合出复杂概念,形成清晰的层次结构。用 requires 约束类的成员函数,可以让类根据模板参数的不同自动"有"或"没有"某些方法,这是一种比 SFINAE 更简洁的条件成员技术。