C++20 概念（Concepts）：模板参数的语义约束定义 | 极客日志

C++算法

C++20 概念（Concepts）：模板参数的语义约束定义

C++20 Concepts 是用于为模板参数定义语义约束的编译期谓词系统。本文介绍了概念的基本定义语法、组合方式及标准库预定义概念。详细讲解了 requires 表达式的四种约束要求：简单要求、类型要求、复合要求和嵌套要求，并结合代码示例说明了其在验证表达式有效性、返回类型及异常规范方面的应用。旨在帮助开发者实现从“语法兼容”到“语义契约”的转变，提升泛型编程的可读性与错误诊断能力。

墨染流年发布于 2026/3/270 浏览

C++20 概念（Concepts）：模板参数的语义约束定义

什么是概念

概念是一套为模板参数定义语义约束的声明式工具。通过 concept 关键字，它将一组类型必须满足的编译期谓词封装为一个命名的语义契约。其本质是提升模板从'语法兼容'到'语义契约'的编译期接口系统。

它将类型需求从隐式的、被动的'鸭子类型'检测，转变为显式的、主动的、由编译器在实例化前验证的设计约束。核心理念是'约束即文档，文档可执行'。

示例

// 定义一个概念
< T>
 Integral = std::is_integral_v<T>;


{
     a + b;
}

(, );      
(, );

concept myconcept = 约束;

template<typename T>
concept Drawable = requires(T t) {
    t.draw();
};

template<typename T>
concept Integral = std::is_integral_v<T>;

template<typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::same_as<std::ostream&>;
};

template<typename T>
concept Serializable = requires(T t) {
    t.serialize();
    T::deserialize;
};

// 组合多个概念
template<typename T>
concept DataObject = Printable<T> && Serializable<T>;

// 基本形式
requires (参数列表 (可选)) {
    要求序列
}

// 完整语法图解
requires-expression:
    requires ( parameter-declaration-clause(opt) ) {
        requirement-seq
    }
requirement-seq:
    requirement requirement-seq
    requirement
requirement:
    simple-requirement       // 简单要求
    type-requirement         // 类型要求
    compound-requirement     // 复合要求
    nested-requirement       // 嵌套要求

template<typename T>
concept HasMethods = requires(T obj) {
    // 验证成员函数存在
    obj.method1();
    obj.method2();
    // 验证操作符存在
    obj + obj;
    -obj;
    // 验证静态成员存在
    T::static_method();
    // 验证友元函数存在
    std::cout << obj;
    // 验证类型转换存在
    static_cast<double>(obj);
    // 验证模板成员函数
    obj.templatemethod<int>();
    // 验证异常规范（C++20 起）
    noexcept(obj.clear());
};

struct Example {
    void method1() {}
    void method2() {}
    Example operator+(const Example&) const { return *this; }
    Example operator-() const { return *this; }
    static void static_method() {}
    template<typename U> void method() {}
    void clear() noexcept {}
};

static_assert(HasMethods<Example>);

template<typename T>
concept HasNestedTypes = requires {
    // 验证嵌套类型存在
    typename T::value_type;
    typename T::iterator;
    typename T::const_iterator;
    typename T::difference_type;
    typename T::size_type;
    // 验证模板嵌套类型
    typename T::template rebind<double>::other;
    // 验证类型别名
    typename std::add_const_t<T>;
    typename std::remove_reference_t<T>;
    // 验证复杂类型表达式
    typename std::conditional_t<sizeof(T)==4, int, double>;
    typename decltype(T{})::value_type;
};

// 带有类型检查的容器概念
template<typename T>
concept AllocatorAwareContainer = requires {
    typename T::value_type;
    typename T::allocator_type;
    typename T::size_type;
    typename T::difference_type;
    typename T::reference;
    typename T::const_reference;
    typename T::pointer;
    typename T::const_pointer;
    typename T::iterator;
    typename T::const_iterator;
    typename T::reverse_iterator;
    typename T::const_reverse_iterator;
    requires std::same_as<typename T::allocator_type::value_type, typename T::value_type>;
};

// 智能指针类型检查
template<typename Ptr>
concept SmartPointer = requires {
    typename Ptr::element_type;
    typename std::add_pointer_t<typename Ptr::element_type>;
};

/* 语法：{ 表达式 } noexcept(可选) -> 类型约束 ; */
template<typename T>
concept CompleteContainer = requires(T container) {
    // 基本检查：表达式有效，不检查返回类型
    { container.begin() };
    { container.end() };
    
    // 检查返回特定类型
    { container.size() } -> std::same_as<typename T::size_type>;
    { container.empty() } -> std::convertible_to<bool>;
    { container.max_size() } -> std::same_as<typename T::size_type>;
    
    // 检查返回类型可转换
    { container[0] } -> std::convertible_to<typename T::reference>;
    { container.at(0) } -> std::convertible_to<typename T::reference>;
    { container.front() } -> std::convertible_to<typename T::reference>;
    { container.back() } -> std::convertible_to<typename T::reference>;
    
    // 检查 noexcept
    { container.clear() } noexcept;
    { container.swap(std::declval<T&>()) } noexcept;
    
    // 组合检查：noexcept + 类型约束
    { container.push_back(std::declval<typename T::value_type>()) } noexcept -> std::same_as<void>;
    
    // 检查可能抛出的操作
    { container.reserve(0) } -> std::same_as<void>;
    
    // 使用 decltype 的复杂类型约束
    { container.data() } -> std::same_as<std::add_pointer_t<typename T::value_type>>;
    
    // 检查成员函数指针
    { &T::size } -> std::same_as<typename T::size_type(T::*)() const>;
};

// 数学类型概念
template<typename T>
concept Arithmetic = requires(T a, T b) {
    // 算术运算返回相同类型
    { a + b } -> std::same_as<T>;
    { a - b } -> std::same_as<T>;
    { a * b } -> std::same_as<T>;
    { a / b } -> std::same_as<T>;
    { -a } -> std::same_as<T>;
    { +a } -> std::same_as<T>;
    
    // 比较运算返回 bool
    { a == b } -> std::convertible_to<bool>;
    { a != b } -> std::convertible_to<bool>;
    { a < b } -> std::convertible_to<bool>;
    { a > b } -> std::convertible_to<bool>;
    { a <= b } -> std::convertible_to<bool>;
    { a >= b } -> std::convertible_to<bool>;
    
    // 复合赋值
    { a += b } -> std::same_as<T&>;
    { a -= b } -> std::same_as<T&>;
    { a *= b } -> std::same_as<T&>;
    { a /= b } -> std::same_as<T&>;
    
    // 自增自减
    { ++a } -> std::same_as<T&>;
    { a++ } -> std::same_as<T>;
    { --a } -> std::same_as<T&>;
    { a-- } -> std::same_as<T>;
};

// 函数对象概念
template<typename F, typename... Args>
concept RegularInvocableWith = requires(F f, Args... args) {
    { std::invoke(f, args...) } noexcept(noexcept(std::invoke(f, args...))) -> std::same_as<std::invoke_result_t<F, Args...>>;
};

// 迭代器概念
template<typename I>
concept DereferenceableIterator = requires(I it) {
    { *it } -> std::same_as<std::iter_reference_t<I>>;
    { it.operator->() } -> std::same_as<std::add_pointer_t<std::remove_reference_t<std::iter_reference_t<I>>>>;
    { it[0] } -> std::same_as<std::iter_reference_t<I>>;
};

template<typename T>
concept ComplexType = requires(T obj) {
    // 简单要求
    obj.operation();
    // 类型要求
    typename T::value_type;
    
    // 嵌套要求：编译时布尔条件
    requires sizeof(T) <= 64;
    requires alignof(T) <= 8;
    requires !std::is_polymorphic_v<T>;
    requires std::is_trivially_copyable_v<T>;
    
    // 嵌套要求：概念检查
    requires std::default_initializable<T>;
    requires std::copyable<T>;
    requires std::movable<T>;
    requires std::totally_ordered<T>;
    
    // 嵌套要求：常量表达式
    requires T::max_size > 0;
    requires (T::version == 1 || T::version == 2);
    
    // 嵌套要求：类型特性
    requires std::is_nothrow_destructible_v<T>;
    requires std::has_virtual_destructor_v<T>;
    
    // 嵌套要求：依赖其他 requires 表达式
    requires requires { obj.nested_operation(); };
    requires requires(T a, T b) { a == b; };
    
    // 嵌套要求：逻辑组合
    requires (std::integral<typename T::value_type> || std::floating_point<typename T::value_type>);
    requires std::same_as<decltype(obj.get()), typename T::value_type*>;
    
    // 嵌套要求：编译时计算
    requires (sizeof(typename T::value_type) * T::element_count <= 1024);
    
    // 嵌套要求：基于模板参数的约束
    requires (std::rank_v<T> == 1);
    
    // 嵌套要求：用户定义类型特性
    requires HasTypeTrait<T>::value;
    
    // 嵌套要求：可变参数模板支持
    requires (std::is_constructible_v<T, int, double, const char*>);
};

// 高级示例：SFINAE 友好概念
template<typename T>
concept Advanced = requires {
    requires requires { typename std::tuple_size<T>::type; typename std::tuple_element_t<0, T>; };
    requires std::is_aggregate_v<T>;
    requires (std::tuple_size_v<T> > 0);
    
    requires requires { T::reflect(); { T::meta_info } -> std::same_as<const char*>; };
    
    requires requires(T obj, std::ostream& os) {
        { obj.serialize(os) } -> std::same_as<std::ostream&>;
    };
    requires requires(T obj, std::istream& is) {
        { T::deserialize(is) } -> std::same_as<T>;
    };
};

// 编译时优化提示概念
template<typename T>
concept Optimizable = requires {
    requires std::is_trivial_v<T>;
    requires std::is_standard_layout_v<T>;
    requires (sizeof(T) % alignof(T) == 0);
    requires std::is_trivially_copyable_v<T>;
    requires std::is_trivially_destructible_v<T>;
    requires !std::is_polymorphic_v<T>;
    requires !std::has_virtual_destructor_v<T>;
    requires std::is_trivially_copy_constructible_v<T>;
    requires std::is_trivially_move_constructible_v<T>;
    requires std::is_trivially_copy_assignable_v<T>;
    requires std::is_trivially_move_assignable_v<T>;
};

// 内存安全概念
template<typename T>
concept MemorySafe = requires {
    requires std::is_nothrow_default_constructible_v<T>;
    requires std::is_nothrow_copy_constructible_v<T>;
    requires std::is_nothrow_move_constructible_v<T>;
    requires std::is_nothrow_copy_assignable_v<T>;
    requires std::is_nothrow_move_assignable_v<T>;
    requires std::is_nothrow_destructible_v<T>;
    requires std::is_nothrow_swappable_v<T>;
    requires (std::is_nothrow_constructible_v<T, int>);
};

// 基本形式
requires(T t) { /* ... */ }

// 多个参数
requires(T t, U u, int n) { /* ... */ }

// 引用参数
requires(T& ref, const T& cref) { /* ... */ }

// 指针参数
requires(T* ptr, const T* cptr) { /* ... */ }

// 右值引用参数
requires(T&& rref) { /* ... */ }

// 数组参数
requires(T arr[10]) { /* ... */ }

// 可变参数模板（C++20 起有限支持）
template<typename... Ts>
concept VariadicConcept = requires(Ts... args) {
    (args + ...);
};

// 默认参数（不允许）
// requires (T t = T{}) { /* ... */ } // 错误！

template<typename T>
concept OrderedEvaluation = requires(T t) {
    requires std::default_initializable<T>;
    requires std::copyable<T>;
    { t.operation2() } -> std::same_as<int>;
    requires requires { t.operation3(); };
};

C++20 概念（Concepts）：模板参数的语义约束定义

C++20 概念（Concepts）：模板参数的语义约束定义

什么是概念

示例

概念的定义语法

基本定义

组合概念

标准库提供的预定义概念（常用部分）

1. 基础类型概念

2. 类型关系概念

3. 比较概念

4. 对象概念

5. 可调用概念

6. 迭代器类别概念

7. 迭代器属性概念

8. 迭代器操作概念

9. 范围概念

10. 范围适配器概念

requires 表达式语法说明

1. requires 表达式的基本语法结构

（1）简单要求 (Simple Requirements)

（2）类型要求 (Type Requirements)

（3）复合要求 (Compound Requirements)

（4）嵌套要求 (Nested Requirements)

参数声明语法

requires 表达式的求值规则

更多推荐文章

相关免费在线工具

C++20 概念（Concepts）：模板参数的语义约束定义

C++20 概念（Concepts）：模板参数的语义约束定义

什么是概念

示例

概念的定义语法

基本定义

组合概念

标准库提供的预定义概念（常用部分）

1. 基础类型概念

2. 类型关系概念

3. 比较概念

4. 对象概念

5. 可调用概念

6. 迭代器类别概念

7. 迭代器属性概念

8. 迭代器操作概念

9. 范围概念

10. 范围适配器概念

requires 表达式语法说明

1. requires 表达式的基本语法结构

（1）简单要求 (Simple Requirements)

（2）类型要求 (Type Requirements)

（3）复合要求 (Compound Requirements)

（4）嵌套要求 (Nested Requirements)

参数声明语法

requires 表达式的求值规则

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具