概念(Concepts)基础定义 ​

什么是概念 ​

概念(Concept)是 C++20 引入的一种语言特性,用来对模板参数施加约束。简单来说,概念就是一个编译期的布尔谓词——它描述了一个类型需要满足的条件,比如"必须是整数类型""必须支持加法运算""必须可以被哈希"等。

在 C++20 之前,模板几乎什么类型都接受,只有在模板实例化时(也就是编译器展开模板代码时)才会发现类型不匹配,然后产生一大堆难以理解的错误信息。概念改变了这种状况:它在模板实例化之前就检查类型是否满足要求,如果不满足,编译器会给出清晰的错误信息——"类型 X 不满足概念 Y"。

概念的定义语法 ​

cpp
template<模板参数列表>
concept 概念名 = 约束表达式;

约束表达式是一个编译期求值为 bool 的表达式。它可以使用类型特征(type_traits)、requires 表达式、其他概念的组合等。

cpp
#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>;

使用概念的四种语法 ​

概念定义好之后,有四种方式把它应用到模板上:

cpp
#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;
}

这四种写法的效果完全一样,选择哪种取决于个人偏好和代码场景。

基本示例 ​

cpp
#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;
}

概念的本质 ​

概念在本质上就是一个编译期的布尔值模板。以下两种写法是等价的:

cpp
// 概念定义
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> 头文件提供了标准库预定义的概念
  • 概念的 && 和 || 有特殊的"包含"语义,影响重载决议

编译器支持情况 ​

编译器最低支持版本
GCC10.0
Clang10.0
MSVC19.26 (VS 2019 16.6)

总结 ​

概念是 C++20 对模板编程最重要的改进之一。它让你可以用简洁的语法描述模板参数必须满足的条件,在编译早期就检测到类型不匹配,给出清晰的错误信息。概念的定义方式很灵活——可以基于类型特征、requires 表达式、或者其他概念的组合。使用方式也有四种(requires 子句、模板参数约束、尾置 requires、简写 auto),覆盖了各种代码风格偏好。概念还参与重载决议,让编译器能根据类型的不同特征自动选择最匹配的函数版本。