概念与重载决议 ​

什么是概念的重载决议 ​

C++20 的概念不仅能约束模板参数、改善错误信息,还深刻参与了重载决议(Overload Resolution)。当多个函数模板都满足约束条件时,编译器会选择"约束更强"的那个版本——这个机制叫做约束的偏序(Partial Ordering of Constraints),核心规则是"包含"(Subsumption)。

简单来说:如果概念 A 的约束条件在逻辑上蕴含了概念 B 的约束条件(A 满足则 B 必然满足),那么 A 就"包含"B,使用 A 约束的函数被认为"更具体",在重载决议中优先被选择。

包含(Subsumption)的基本规则 ​

编译器判断约束之间的包含关系时,会把约束展开为原子约束的合取/析取范式,然后检查一个约束的所有析取子句是否能蕴含另一个约束的所有合取子句。

关键要点:

  • A && B 包含 A(更具体包含更通用)
  • A && B 包含 B
  • A 不包含 A && B
  • A 包含 A || B(更通用被更具体包含)
  • 包含关系只在通过概念展开时才成立,直接写的 requires 表达式被视为原子约束

基本示例 ​

cpp
#include <iostream>
#include <concepts>
#include <string>
#include <type_traits>

// ============================
// 示例1:标准概念的包含关系
// ============================

// std::signed_integral 的定义大致是:
// std::integral<T> && std::is_signed_v<T>
// 所以 signed_integral 包含 integral

// 通用版本:接受所有整数
template<std::integral T>
std::string describe(T value) {
    return "整数: " + std::to_string(value);
}

// 更具体版本:只接受有符号整数
// signed_integral 包含 integral,所以更具体
template<std::signed_integral T>
std::string describe(T value) {
    return "有符号整数: " + std::to_string(value);
}

void subsumption_demo() {
    int x = 42;
    unsigned int y = 42u;

    // int 同时满足 integral 和 signed_integral
    // 但 signed_integral 更具体,所以选它
    std::cout << describe(x) << std::endl;   // "有符号整数: 42"

    // unsigned int 只满足 integral,不满足 signed_integral
    // 所以选 integral 版本
    std::cout << describe(y) << std::endl;   // "整数: 42"
}

// ============================
// 示例2:自定义概念的层次化重载
// ============================

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

template<typename T>
concept PrintableAndSizable = Printable<T> && requires(T v) {
    { v.size() } -> std::convertible_to<std::size_t>;
};

// 通用版本
template<Printable T>
void log(const T& value) {
    std::cout << "[值] " << value << std::endl;
}

// 更具体版本:可打印且有 size()
template<PrintableAndSizable T>
void log(const T& value) {
    std::cout << "[值,大小=" << value.size() << "] " << value << std::endl;
}

void custom_hierarchy_demo() {
    log(42);                        // int 只满足 Printable
    log(std::string("hello"));      // string 满足 PrintableAndSizable(更具体)
}

// ============================
// 示例3:无约束 vs 有约束
// ============================

// 无约束版本
template<typename T>
void process(T value) {
    std::cout << "通用处理" << std::endl;
}

// 有约束版本
template<std::integral T>
void process(T value) {
    std::cout << "整数处理: " << value << std::endl;
}

// 更强约束版本
template<std::signed_integral T>
void process(T value) {
    std::cout << "有符号整数处理: " << value << std::endl;
}

void unconstrained_vs_constrained_demo() {
    process(3.14);      // double:只匹配无约束版本
    process(42u);       // unsigned int:匹配 integral 版本(更具体)
    process(42);        // int:匹配 signed_integral 版本(最具体)
    process("hello");   // const char*:只匹配无约束版本
}

// ============================
// 示例4:概念用于类模板特化
// ============================

// 主模板
template<typename T>
struct Formatter {
    static std::string format(const T& value) {
        return "unknown";
    }
};

// 整数类型的特化
template<std::integral T>
struct Formatter<T> {
    static std::string format(T value) {
        return "int:" + std::to_string(value);
    }
};

// 有符号整数的特化(更具体,优先匹配)
template<std::signed_integral T>
struct Formatter<T> {
    static std::string format(T value) {
        return "signed:" + std::to_string(value);
    }
};

// 浮点类型的特化
template<std::floating_point T>
struct Formatter<T> {
    static std::string format(T value) {
        return "float:" + std::to_string(value);
    }
};

void class_specialization_demo() {
    std::cout << Formatter<int>::format(42) << std::endl;         // signed:42
    std::cout << Formatter<unsigned>::format(42u) << std::endl;   // int:42
    std::cout << Formatter<double>::format(3.14) << std::endl;    // float:3.140000
    std::cout << Formatter<std::string>::format("hi") << std::endl;  // unknown
}

// ============================
// 示例5:包含关系不成立的情况
// ============================

// 两个独立的概念,互不包含
template<typename T>
concept HasSize = requires(T v) { v.size(); };

template<typename T>
concept HasBegin = requires(T v) { v.begin(); };

// 如果这两个版本对同一类型都满足,会产生歧义
// template<HasSize T> void ambiguous(T v) {}
// template<HasBegin T> void ambiguous(T v) {}
// ambiguous(std::vector<int>{}); // 编译错误:歧义

// 解决方案:定义一个组合概念来消除歧义
template<typename T>
concept SizedAndIterable = HasSize<T> && HasBegin<T>;

template<HasSize T>
void no_ambiguity(const T& v) {
    std::cout << "有 size()" << std::endl;
}

template<SizedAndIterable T>
void no_ambiguity(const T& v) {
    std::cout << "有 size() 且可迭代" << std::endl;
}

void ambiguity_demo() {
    // vector 同时满足 HasSize 和 SizedAndIterable
    // SizedAndIterable 包含 HasSize,所以选更具体的
    std::vector<int> vec{1, 2, 3};
    no_ambiguity(vec);  // "有 size() 且可迭代"
}

int main() {
    std::cout << "=== 标准概念包含 ===" << std::endl;
    subsumption_demo();

    std::cout << "\n=== 自定义层次 ===" << std::endl;
    custom_hierarchy_demo();

    std::cout << "\n=== 无约束 vs 有约束 ===" << std::endl;
    unconstrained_vs_constrained_demo();

    std::cout << "\n=== 类模板特化 ===" << std::endl;
    class_specialization_demo();

    std::cout << "\n=== 消除歧义 ===" << std::endl;
    ambiguity_demo();

    return 0;
}

重载决议的优先级 ​

当多个候选函数都可行时,编译器按以下顺序选择:

优先级规则
最高参数转换更好(精确匹配 > 转换)
非模板函数优先于模板函数
更特化的模板优先于更通用的模板
约束更强的模板优先于约束更弱的模板
最低无约束模板

包含关系成立与不成立的情况 ​

场景是否成立原因
std::signed_integral vs std::integral成立signed_integral 定义中包含 integral
A && B vs A成立合取包含其子项
两个独立概念 HasSize vs HasBegin不成立互不相关
相同的 requires 表达式写在两个地方不成立非概念展开的原子约束按声明位置比较
概念 C vs 用相同逻辑写的 requires不成立必须通过同一概念展开才能比较

适用场景 ​

  • 为不同类型类别提供不同实现(如整数用位运算,浮点用数学函数)
  • 类模板的概念驱动偏特化
  • 泛型库中根据类型能力选择最优算法
  • 提供通用回退实现和特化优化实现

常见问题 ​

两个约束同样具体会怎样?

如果两个函数模板的约束互不包含,且都满足当前类型,编译器会报歧义错误。解决方法是定义一个组合概念来建立包含关系。

直接写的 requires 表达式参与包含比较吗?

不参与。两个直接写的 requires 表达式即使内容完全一样,也被视为不同的原子约束,不能建立包含关系。要让包含关系成立,必须通过命名概念来间接引用。

cpp
// 这两个函数会歧义(即使 requires 内容相同)
template<typename T> requires requires(T a) { a.size(); }
void f(T) {}

template<typename T> requires requires(T a) { a.size(); } && requires(T a) { a.begin(); }
void f(T) {}

// 正确做法:用命名概念
template<typename T> concept HasSize = requires(T a) { a.size(); };
template<typename T> concept HasSizeAndBegin = HasSize<T> && requires(T a) { a.begin(); };

非模板函数和受约束模板函数哪个优先?

非模板函数优先。只有在没有完全匹配的非模板函数时,才会比较模板函数之间的约束强弱。

注意事项 ​

  • 包含关系只通过概念展开建立,直接写的 requires 表达式是原子约束
  • 设计概念时应该有意识地建立层次结构(通用 -> 具体)
  • 用 && 组合概念会让约束"更强",在重载决议中优先
  • 独立的概念之间没有包含关系,同时满足会导致歧义
  • || 组合让约束"更弱"(接受更多类型)
  • 取反 ! 不参与包含关系计算

编译器支持情况 ​

编译器最低支持版本
GCC10.0
Clang10.0(部分偏序规则 12.0+)
MSVC19.26 (VS 2019 16.6)

总结 ​

概念参与重载决议是 C++20 概念系统最强大的特性之一。通过包含(subsumption)机制,编译器可以在多个满足条件的重载中自动选择"约束最强"(最具体)的版本。这个机制的关键是概念之间的层次关系:如果概念 A 的定义中使用了概念 B(例如 concept A = B<T> && 额外条件),那么 A 包含 B,用 A 约束的函数在重载决议中优于用 B 约束的函数。设计概念时应该有意识地建立这种层次结构——从通用到具体。注意包含关系只通过命名概念建立,直接写的 requires 表达式是原子约束,不参与包含比较。