标准概念库 ​

什么是标准概念库 ​

C++20 在 <concepts> 头文件中提供了一套预定义的标准概念,覆盖了类型关系、算术类型、生命周期管理、对象语义、可调用类型等常见的类型约束需求。这些概念是标准库和用户代码中最常用的构建块——你可以直接拿来用,也可以基于它们组合出更复杂的自定义概念。

标准概念库的设计原则是:概念不仅描述语法要求("这个类型有哪些操作"),还隐含语义要求("这些操作应该怎么表现")。比如 std::regular 不仅要求类型可以复制和比较,还隐含"复制出来的对象和原来的相等"这样的语义约束。

头文件 ​

cpp
#include <concepts>

标准概念分类总览 ​

核心语言概念 ​

概念含义
std::same_as<T, U>T 和 U 是同一类型
std::derived_from<Derived, Base>Derived 公有继承自 Base
std::convertible_to<From, To>From 可以隐式转换为 To
std::common_reference_with<T, U>T 和 U 有公共引用类型
std::common_with<T, U>T 和 U 有公共类型

算术类型概念 ​

概念含义
std::integral<T>T 是整数类型(含 bool、char)
std::signed_integral<T>T 是有符号整数类型
std::unsigned_integral<T>T 是无符号整数类型
std::floating_point<T>T 是浮点类型

生命周期概念 ​

概念含义
std::destructible<T>T 可以被析构
std::constructible_from<T, Args...>T 可以用 Args... 构造
std::default_initializable<T>T 可以默认构造
std::move_constructible<T>T 可以移动构造
std::copy_constructible<T>T 可以复制构造

赋值概念 ​

概念含义
std::assignable_from<LHS, RHS>可以把 RHS 赋值给 LHS
std::swappable<T>T 的对象可以交换
std::swappable_with<T, U>T 和 U 的对象可以互相交换

比较概念 ​

概念含义
std::equality_comparable<T>T 支持 == 和 !=
std::equality_comparable_with<T, U>T 和 U 之间可以比较相等
std::totally_ordered<T>T 支持全序比较(<、>、<=、>=、==、!=)
std::totally_ordered_with<T, U>T 和 U 之间支持全序比较

对象概念 ​

概念含义包含的要求
std::movable<T>可移动的对象类型对象类型 + 移动构造 + 移动赋值 + 可交换
std::copyable<T>可复制的对象类型movable + 复制构造 + 复制赋值
std::semiregular<T>半正则类型copyable + 默认构造
std::regular<T>正则类型semiregular + equality_comparable

可调用概念 ​

概念含义
std::invocable<F, Args...>F 可以用 Args... 调用
std::regular_invocable<F, Args...>F 可以用 Args... 调用(不修改状态)
std::predicate<F, Args...>F 是返回 bool 的谓词
std::relation<R, T, U>R 是 T 和 U 之间的二元关系
std::equivalence_relation<R, T, U>R 是等价关系
std::strict_weak_order<R, T, U>R 是严格弱序

基本示例 ​

cpp
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <functional>
#include <memory>

// ============================
// 示例1:算术类型概念
// ============================

// 只接受整数类型
template<std::integral T>
T gcd(T a, T b) {
    while (b != 0) {
        T temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 只接受浮点类型
template<std::floating_point T>
bool nearly_equal(T a, T b, T epsilon = T(1e-6)) {
    return (a - b < epsilon) && (b - a < epsilon);
}

// 有符号整数
template<std::signed_integral T>
T safe_abs(T value) {
    return value < 0 ? -value : value;
}

void arithmetic_demo() {
    std::cout << "gcd(12, 8) = " << gcd(12, 8) << std::endl;          // 4
    std::cout << "gcd(100, 75) = " << gcd(100, 75) << std::endl;      // 25

    std::cout << std::boolalpha;
    std::cout << "nearly_equal(0.1+0.2, 0.3) = "
              << nearly_equal(0.1 + 0.2, 0.3) << std::endl;            // true

    std::cout << "safe_abs(-42) = " << safe_abs(-42) << std::endl;     // 42

    // gcd(3.14, 2.0);     // 编译错误:double 不满足 integral
    // safe_abs(42u);       // 编译错误:unsigned int 不满足 signed_integral
}

// ============================
// 示例2:类型关系概念
// ============================

struct Animal { virtual ~Animal() = default; };
struct Dog : public Animal {};
struct Cat : public Animal {};

// 要求 T 继承自 Animal
template<std::derived_from<Animal> T>
void feed(const T& pet) {
    std::cout << "喂食动物" << std::endl;
}

// 要求 From 可以转换为 To
template<typename From, typename To>
    requires std::convertible_to<From, To>
To convert(From value) {
    return static_cast<To>(value);
}

void relationship_demo() {
    Dog dog;
    Cat cat;
    feed(dog);       // Dog 继承自 Animal,通过
    feed(cat);       // Cat 继承自 Animal,通过
    // feed(42);     // int 不继承自 Animal,编译错误

    double d = convert<int, double>(42);
    std::cout << "convert<int, double>(42) = " << d << std::endl;
}

// ============================
// 示例3:对象概念层级
// ============================

// std::regular 是最严格的对象概念:
// 可默认构造 + 可复制 + 可移动 + 可交换 + 支持 ==

template<std::regular T>
class ValueWrapper {
    T value_;
public:
    ValueWrapper() = default;
    explicit ValueWrapper(T v) : value_(std::move(v)) {}
    const T& get() const { return value_; }

    bool operator==(const ValueWrapper&) const = default;
};

// std::movable 是最宽松的对象概念
template<std::movable T>
class MoveOnlyWrapper {
    T value_;
public:
    explicit MoveOnlyWrapper(T v) : value_(std::move(v)) {}
    const T& get() const { return value_; }
};

void object_concept_demo() {
    // int 满足 regular
    ValueWrapper<int> w1(42);
    ValueWrapper<int> w2(42);
    std::cout << "w1 == w2: " << std::boolalpha << (w1 == w2) << std::endl;

    // unique_ptr 只满足 movable,不满足 copyable
    MoveOnlyWrapper<std::unique_ptr<int>> mw(std::make_unique<int>(99));
    std::cout << "move-only wrapper: " << *mw.get() << std::endl;

    // 以下编译错误:unique_ptr 不满足 regular
    // ValueWrapper<std::unique_ptr<int>> fail;
}

// ============================
// 示例4:可调用概念
// ============================

// 要求 F 是可以用 int, int 调用的函数
template<std::invocable<int, int> F>
int apply_binary(F func, int a, int b) {
    return func(a, b);
}

// 要求 F 是返回 bool 的谓词
template<typename T, std::predicate<T> F>
std::vector<T> filter(const std::vector<T>& data, F pred) {
    std::vector<T> result;
    for (const auto& item : data) {
        if (pred(item)) {
            result.push_back(item);
        }
    }
    return result;
}

void callable_demo() {
    // 普通函数
    auto result = apply_binary([](int a, int b) { return a + b; }, 3, 4);
    std::cout << "apply_binary(+, 3, 4) = " << result << std::endl;

    // 谓词过滤
    std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto evens = filter(nums, [](int n) { return n % 2 == 0; });

    std::cout << "偶数: ";
    for (int n : evens) std::cout << n << " ";
    std::cout << std::endl;
}

// ============================
// 示例5:比较概念
// ============================

template<std::equality_comparable T>
bool contains(const std::vector<T>& vec, const T& target) {
    for (const auto& item : vec) {
        if (item == target) return true;
    }
    return false;
}

template<std::totally_ordered T>
T find_max(const std::vector<T>& vec) {
    T max_val = vec[0];
    for (std::size_t i = 1; i < vec.size(); ++i) {
        if (vec[i] > max_val) max_val = vec[i];
    }
    return max_val;
}

void comparison_demo() {
    std::vector<int> nums{3, 1, 4, 1, 5, 9};
    std::cout << "contains 5: " << std::boolalpha << contains(nums, 5) << std::endl;
    std::cout << "max: " << find_max(nums) << std::endl;

    std::vector<std::string> words{"hello", "world", "cpp"};
    std::cout << "max word: " << find_max(words) << std::endl;
}

int main() {
    std::cout << "=== 算术类型 ===" << std::endl;
    arithmetic_demo();

    std::cout << "\n=== 类型关系 ===" << std::endl;
    relationship_demo();

    std::cout << "\n=== 对象概念 ===" << std::endl;
    object_concept_demo();

    std::cout << "\n=== 可调用 ===" << std::endl;
    callable_demo();

    std::cout << "\n=== 比较 ===" << std::endl;
    comparison_demo();

    return 0;
}

对象概念的层级关系 ​

标准库的四个对象概念形成一个由宽到严的层级:

movable          ← 最基础:对象类型 + 移动构造 + 移动赋值 + 可交换
  ↑
copyable         ← movable + 复制构造 + 复制赋值
  ↑
semiregular      ← copyable + 默认构造
  ↑
regular          ← semiregular + 支持 ==(equality_comparable)
类型示例movablecopyablesemiregularregular
int满足满足满足满足
std::string满足满足满足满足
std::unique_ptr满足不满足不满足不满足
std::vector<int>满足满足满足满足

适用场景 ​

  • 约束泛型函数的参数类型(最常见用法)
  • 在自定义概念中组合使用标准概念
  • 为容器和算法定义类型要求
  • 替代 <type_traits> 中的类型判断(语法更简洁)
  • 模板函数重载决议——让编译器根据概念选择最匹配的版本

常见问题 ​

std::integral 包含 bool 和 char 吗?

包含。std::integral 等价于 std::is_integral_v<T>,它包括 bool、char、signed char、unsigned char、wchar_t、char8_t、char16_t、char32_t 以及所有整数类型。如果你只想要"数学意义上的整数",需要自己排除 bool 和字符类型。

same_as 和 is_same_v 有什么区别?

语义一样,但 same_as 是概念,可以用在约束中;is_same_v 是类型特征变量模板,不能直接用在概念的约束语法中。另外 same_as<T, U> 是对称的(same_as<T, U> 包含 same_as<U, T>),is_same_v 本来也是对称的但在某些模板偏序场景下表现不同。

invocable 和 regular_invocable 有什么区别?

语法上没有区别——它们的约束条件相同。区别是语义上的:regular_invocable 额外要求调用不会修改可调用对象或参数的状态(类似数学函数)。编译器不检查这个语义约束,它是对使用者的一种文档化约定。

standard concepts 在 <concepts> 之外还有吗?

有。<iterator> 中定义了迭代器相关概念(如 std::input_iterator、std::random_access_iterator),<ranges> 中定义了范围概念(如 std::ranges::range、std::ranges::view)。

注意事项 ​

  • 标准概念既有语法要求也有语义要求,编译器只检查语法部分
  • std::integral 包含 bool 和字符类型,使用时注意是否需要排除
  • 概念之间有包含关系(subsumption),影响重载决议
  • 组合标准概念时用 && 和 ||,不要在概念定义中用 !(取反不参与包含关系)
  • 优先使用标准概念,不要重复造轮子

编译器支持情况 ​

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

总结 ​

标准概念库(<concepts>)提供了约 30 个预定义概念,覆盖了类型关系(same_as、derived_from、convertible_to)、算术类型(integral、floating_point)、生命周期(constructible_from、move_constructible)、对象语义(movable、copyable、semiregular、regular)、比较(equality_comparable、totally_ordered)和可调用(invocable、predicate)等方面。这些概念是模板约束的基础构建块,可以直接使用,也可以组合成更复杂的自定义概念。使用标准概念代替手写类型特征判断,代码更简洁、错误信息更清晰、重载决议更智能。