Concepts 基础

C++20 引入的 Concepts 是模板编程最重要的改进之一。它让我们可以用清晰、可读的语法声明模板参数必须满足的约束条件,从根本上解决了模板错误信息难以理解的历史性痛点。

1. 为什么需要 Concepts

在 C++20 之前,约束模板参数的唯一方式是 SFINAE(Substitution Failure Is Not An Error)。SFINAE 虽然强大,但有两个致命缺点:语法晦涩、错误信息灾难。

C++17:SFINAE 时代的错误信息

假设我们写了一个只接受数值类型的加法函数:

// C++17: 用 SFINAE 约束
template<typename T,
         typename = std::enable_if_t<std::is_arithmetic_v<T>>>
T add(T a, T b) {
    return a + b;
}

// 当用户传入 std::string 时...
auto result = add(std::string("hello"), std::string("world"));

编译器输出(GCC 示例,已简化):

// error: no matching function for call to 'add(std::string, std::string)'
//   candidate: template<class T, class> T add(T, T)
//   template argument deduction/substitution failed:
//     error: no type named 'type' in
//       'struct std::enable_if<false, void>'
// ... 还有 20 行关于 enable_if 内部实现的信息

C++20:Concepts 时代的错误信息

// C++20: 用 Concept 约束
template<typename T>
concept Numeric = std::is_arithmetic_v<T>;

template<Numeric T>
T add(T a, T b) {
    return a + b;
}

// 同样传入 std::string...
auto result = add(std::string("hello"), std::string("world"));

编译器输出:

// error: no matching function for call to 'add(std::string, std::string)'
//   note: constraints not satisfied
//   note: the required expression 'std::is_arithmetic_v<T>' is not satisfied
//         with T = std::basic_string<char>
// 就这么多。清晰明了。

核心价值:Concepts 不只是语法糖——它们从根本上改变了编译器理解和报告模板约束的方式。错误信息从"替换失败导致 enable_if 内部类型不存在"变成了"类型 T 不满足约束 Numeric"。

2. Concept 定义语法

Concept 本质上是一个编译期布尔值的命名。其基本语法为:

template<typename T>
concept 概念名 = 约束表达式;

基于类型特征定义

最简单的方式是直接复用现有的 type_traits:

#include <type_traits>
#include <concepts>

// 基于 type_traits 的简单 concept
template<typename T>
concept Numeric = std::is_arithmetic_v<T>;

// 组合多个 traits
template<typename T>
concept SignedNumeric = std::is_arithmetic_v<T> && std::is_signed_v<T>;

// 使用逻辑运算符
template<typename T>
concept StringLike = std::is_convertible_v<T, std::string_view>;

基于 requires 表达式定义

更强大的方式是用 requires 表达式直接检查类型是否支持特定操作:

// 检查是否可比较
template<typename T>
concept Sortable = requires(T a, T b) {
    { a < b } -> std::convertible_to<bool>;
};

// 检查是否有特定成员
template<typename T>
concept Container = requires(T c) {
    typename T::value_type;          // 类型要求
    typename T::iterator;
    { c.begin() } -> std::input_or_output_iterator;
    { c.end() } -> std::input_or_output_iterator;
    { c.size() } -> std::integral;
};

// 检查是否可序列化为字符串
template<typename T>
concept Printable = requires(std::ostream& os, T val) {
    { os << val } -> std::same_as<std::ostream&>;
};

三种 requires 需求类型

需求类型语法检查内容
简单需求expr;表达式是否合法(不求值)
类型需求typename T::X;类型是否存在
复合需求{ expr } -> concept;表达式合法 + 返回类型满足约束

3. 使用 Concepts 约束模板

C++20 提供了四种等价的语法来约束模板参数。选择哪种取决于上下文和可读性偏好。

语法一:约束模板参数(推荐)

// 直接在 template<> 中使用 concept 名替代 typename
template<Numeric T>
T add(T a, T b) {
    return a + b;
}

// 多个参数可以使用不同约束
template<Numeric T, Printable U>
void log_and_add(T val, U label) {
    std::cout << label << ": " << val + val << '\n';
}

语法二:requires 子句(前置)

// requires 子句放在模板参数列表之后
template<typename T>
    requires Numeric<T>
T add(T a, T b) {
    return a + b;
}

// 适合复杂约束表达式
template<typename T>
    requires Numeric<T> && (sizeof(T) >= 4)
T precise_add(T a, T b) {
    return a + b;
}

语法三:简写函数模板(最简洁)

// 使用 concept auto 参数——编译器自动推导模板
auto add(Numeric auto a, Numeric auto b) {
    return a + b;
}

// 注意:这里 a 和 b 可以是不同类型!
auto x = add(1, 2.5);  // int + double = double

// 等价于:
// template<Numeric T, Numeric U>
// auto add(T a, U b) { return a + b; }

语法四:requires 子句(后置)

// requires 放在函数声明末尾
template<typename T>
T add(T a, T b) requires Numeric<T> {
    return a + b;
}

// 适合成员函数和虚函数场景
class Calculator {
    template<typename T>
    T compute(T a, T b) requires Numeric<T>;
};

选择建议:

  • 简单约束:用语法一(template<Numeric T>),最清晰
  • 自由函数 + 自动推导:用语法三(Numeric auto),最简洁
  • 复杂/组合约束:用语法二(前置 requires),约束表达式可以写多行
  • 成员函数:用语法四(后置 requires),避免打断声明

4. requires 表达式详解

requires 表达式是 Concepts 的核心构建块。它在编译期检查一组操作是否对给定类型合法,返回 bool。

简单需求(Simple Requirement)

只检查表达式是否格式正确(well-formed),不求值也不检查返回类型:

template<typename T>
concept Addable = requires(T x) {
    x + x;      // 只检查 T 是否支持 operator+
    x - x;      // 只检查 T 是否支持 operator-
    -x;         // 只检查一元取负
};

// std::string 满足 Addable(因为 string 有 operator+)
// 但语义可能不是你想要的——这就是为什么需要更精确的约束

类型需求(Type Requirement)

检查某个类型名是否存在:

template<typename T>
concept HasValueType = requires {
    typename T::value_type;       // T 必须有 value_type 成员类型
    typename T::iterator;         // T 必须有 iterator 成员类型
    typename T::size_type;        // T 必须有 size_type 成员类型
};

// std::vector<int> 满足 HasValueType
// int 不满足

复合需求(Compound Requirement)

同时检查表达式合法性、返回类型和可选的 noexcept 属性:

template<typename T>
concept Sizable = requires(T c) {
    // 语法: { 表达式 } noexcept(可选) -> 类型约束;
    { c.size() } noexcept -> std::integral;
    // 意思:c.size() 必须:
    //   1. 是合法表达式
    //   2. 不抛异常
    //   3. 返回类型满足 std::integral
};

template<typename T>
concept Hashable = requires(T val) {
    { std::hash<T>{}(val) } -> std::convertible_to<std::size_t>;
};

嵌套需求(Nested Requirement)

在 requires 表达式内部添加额外的编译期布尔约束:

template<typename T>
concept LargeNumeric = requires {
    requires std::is_arithmetic_v<T>;   // 必须是算术类型
    requires sizeof(T) >= 4;            // 至少 4 字节
    requires !std::is_same_v<T, bool>;  // 排除 bool
};

// int      ✓ (算术类型, 4字节, 不是 bool)
// double   ✓ (算术类型, 8字节, 不是 bool)
// char     ✗ (算术类型, 但只有 1 字节)
// bool     ✗ (算术类型, 但被显式排除)

注意区分两种 requires:

  • requires 子句(clause):约束模板的语法,放在模板声明中
  • requires 表达式(expression):产生 bool 值的编译期表达式

两者可以组合:template<typename T> requires requires(T x) { x + x; }——第一个 requires 是子句,第二个是表达式。这被戏称为"requires requires"模式,虽然合法但应避免使用,请提取为命名 concept。

5. 标准概念库 (<concepts>)

C++20 在 <concepts> 和 <iterator> 头文件中提供了大量预定义 Concepts。优先使用标准概念,避免重复造轮子。

核心语言概念

Concept含义示例满足类型
std::same_as<T, U>T 和 U 是相同类型same_as<int, int>
std::derived_from<D, B>D 公开继承自 B子类与基类
std::convertible_to<From, To>From 可隐式转换为 Toint → double
std::integral整数类型int, long, char
std::floating_point浮点类型float, double
std::signed_integral有符号整数int, long
std::unsigned_integral无符号整数unsigned, size_t

比较概念

Concept含义
std::equality_comparable支持 == 和 !=
std::totally_ordered支持 < > <= >= 和相等比较
std::three_way_comparable支持 <=>

对象概念

Concept含义
std::movable可移动构造 + 可移动赋值
std::copyable可拷贝 + 可移动
std::semiregular可拷贝 + 可默认构造
std::regularsemiregular + equality_comparable

可调用概念

Concept含义
std::invocable<F, Args...>F 可用 Args... 调用
std::predicate<F, Args...>invocable 且返回 bool
std::relation<F, T, U>二元关系谓词

Ranges 概念(<ranges>)

#include <ranges>

// 常用 range concepts
template<std::ranges::range R>
void process(R&& rng);                    // 任何 range

template<std::ranges::input_range R>
void read_all(R&& rng);                   // 可读遍历

template<std::ranges::random_access_range R>
void sort_it(R&& rng);                    // 支持随机访问

template<std::ranges::sized_range R>
void reserve_and_copy(R&& rng);            // 可 O(1) 获取大小

6. Concepts vs SFINAE 对比

维度SFINAE (C++11/14/17)Concepts (C++20)
可读性 enable_if_t<is_arithmetic_v<T>> Numeric T
错误信息 几十行模板展开 1-3 行:哪个约束不满足
组合约束 嵌套 enable_if + conjunction && / || 直接组合
重载决议 不参与排序 更特化的 concept 优先匹配
文档价值 需要额外注释 concept 名本身就是文档
学习曲线 极陡峭 平缓,接近自然语言
// SFINAE 实现:只接受容器类型
template<typename C,
    typename = std::enable_if_t<
        std::is_same_v<
            decltype(std::declval<C>().begin()),
            typename C::iterator
        >
    >>
void print_all(const C& container) {
    for (auto&& elem : container)
        std::cout << elem << ' ';
}

// Concepts 实现:清晰简洁
void print_all(const std::ranges::range auto& container) {
    for (auto&& elem : container)
        std::cout << elem << ' ';
}

实践原则:所有新代码都应使用 Concepts。SFINAE 仅在维护旧代码或需要支持 C++17 编译器时使用。

7. 实用例子

例一:通用容器打印器

#include <iostream>
#include <concepts>
#include <ranges>
#include <vector>
#include <list>
#include <map>

// 定义 Printable concept
template<typename T>
concept Printable = requires(std::ostream& os, T val) {
    { os << val } -> std::same_as<std::ostream&>;
};

// 打印任何元素可输出的 range
void print_range(std::ranges::range auto const& rng)
    requires Printable<std::ranges::range_value_t<
        decltype(rng)>>
{
    std::cout << "[";
    bool first = true;
    for (auto const& elem : rng) {
        if (!first) std::cout << ", ";
        std::cout << elem;
        first = false;
    }
    std::cout << "]\n";
}

int main() {
    std::vector<int> v{1, 2, 3, 4, 5};
    std::list<double> l{1.1, 2.2, 3.3};

    print_range(v);   // [1, 2, 3, 4, 5]
    print_range(l);   // [1.1, 2.2, 3.3]
}

例二:受约束的数值累加

#include <concepts>
#include <ranges>
#include <numeric>
#include <vector>

// Concept: 可以相加的数值类型
template<typename T>
concept Summable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
} && std::default_initializable<T>;

// 只接受元素可累加的 range
template<std::ranges::input_range R>
    requires Summable<std::ranges::range_value_t<R>>
auto accumulate(R&& rng) {
    using T = std::ranges::range_value_t<R>;
    T sum{};
    for (auto const& val : rng) {
        sum = sum + val;
    }
    return sum;
}

int main() {
    std::vector<int> nums{1, 2, 3, 4, 5};
    auto total = accumulate(nums);  // 15

    // std::vector<std::mutex> 会被拒绝——
    // std::mutex 不可加,约束清晰地告知原因
}

例三:Hashable concept

#include <concepts>
#include <functional>
#include <string>
#include <unordered_set>

// 检查类型是否可以作为 unordered 容器的键
template<typename T>
concept Hashable = requires(T val) {
    { std::hash<T>{}(val) } -> std::convertible_to<std::size_t>;
} && std::equality_comparable<T>;

// 只接受可哈希的类型
template<Hashable Key>
class UniqueStore {
    std::unordered_set<Key> data_;
public:
    void insert(Key const& key) { data_.insert(key); }
    bool contains(Key const& key) const { return data_.contains(key); }
    std::size_t size() const { return data_.size(); }
};

int main() {
    UniqueStore<std::string> store;   // OK: string 可哈希
    store.insert("hello");
    store.insert("world");
    store.insert("hello");  // 重复,不插入
    // store.size() == 2

    // UniqueStore<std::vector<int>> bad;  // 编译错误!
    // error: constraints not satisfied: Hashable<std::vector<int>>
    // note: 'std::hash<std::vector<int>>{}(val)' is not a valid expression
}

本章小结

  • Concept = 命名的编译期类型约束,用 concept 关键字定义
  • 四种约束语法任选其一:template<C T>、前置 requires、C auto、后置 requires
  • requires 表达式支持简单/类型/复合/嵌套四种需求
  • 标准库 <concepts> 提供丰富的预定义 concepts:integral、floating_point、invocable 等
  • 相比 SFINAE,Concepts 的错误信息、可读性、可组合性全方位碾压
  • 新代码一律使用 Concepts,SFINAE 仅用于旧代码兼容