夜雨聆风学习资料网

ARTICLE · 1365649

模板报错像天文数字?C++20 概念怎么一步步逼出来的

模板报错像天文数字?C++20 概念怎么一步步逼出来的

字数约 3400 | 阅读约 5 分钟 | C++20

引子:你看过最长的编译报错有多长?

如果你是写模板的人,八成被编译器的报错教育过:你只是传错了两个参数,编译器却甩给你四五十行——开头在 std 库源码深处,结尾还要往上翻半天才看到一个 required from here。

更要命的是,你到现在也不确定"它到底想让我传什么"。

C++20 的概念(concept)就是冲着这个痛点来的。但它不是凭空冒出来的语法,而是模板开发被报错反复折磨后,一步步逼出来的解药。

今天这篇,我们就顺着时间线,看它是怎么"长"出来的。

第一步:裸模板,完全不设防

先从最朴素的一个模板函数讲起。我们要写一个取最大值的工具:

// C++20#include<iostream>template<typename T>T maxValue(T a, T b){return b < a ? a : b;}intmain(){    std::cout << maxValue(42, 77) << '\n';           // 正常:77}

输出:

77

这个模板看着人畜无害,其实有两个毛病:

毛病一:什么都能传,包括"不该比"的东西。maxValue("apple", "pear") 还挺能编译——因为传进去的是两个 const char* 指针,b < a 比的是地址,不是单词在字典里的顺序。结果对不对纯看运气:地址顺序和字典顺序没有任何关系,换个运行环境可能就错。

模板太宽松,"有用的类型"和"没意义但能编译的类型"它分不清。

毛病二:真出错时,报错像天文数字。

试着传一个 int 和一个字符串字面量:

maxValue(42, "hello");   // <-- 想比大小,但 42 是 int,"hello" 是 const char[6]

你可以看到这样的报错(节选,实际排版更长;不同编译器把第二个参数写成 const char[6] 或 const char*,措辞有出入):

error: no matching function for call to 'maxValue(int, const char[6])'note: candidate: 'template<class T> T maxValue(T, T)'note:   template argument deduction/substitution failed:note:   deduced conflicting types for parameter 'T'       ('int' and 'const char[6]')note: candidate: 'T maxValue(T, T) [with T = …]'…

这还只是"类型对不上"的报错。真正的灾难来自另一类场景——模板函数体内部悄悄依赖了一些操作,这些操作在标准库的层层实例化深处才被发现,报错能翻好几屏。想象这个更常见的泛型写法:

// C++20(示意代码,会触发编译错误)#include<vector>#include<thread>template<typename Coll, typename T>voidaddItem(Coll& coll, const T& val){    coll.push_back(val);   // 要求 Coll 支持 push_back(),且元素可拷贝}intmain(){    std::vector<int> numbers;addItem(numbers, 42);          // OK    std::thread t;                 // 一个不能拷贝的线程对象    std::vector<std::thread> tasks;addItem(tasks, t);             // ← 问题来了:thread 不能拷贝}

报错节选(各编译器措辞略有出入):

…/include/bits/stl_construct.h: In 'void std::_Construct(_Tp*)':error: use of deleted function 'std::thread::thread(const std::thread&)'……/include/bits/stl_uninitialized.h: … required from '…push_back…'…/include/bits/stl_vector.h: … required from '…'…/addDemo.cpp: required from here

报错的位置在 stl_construct.h 里——那是标准库实现文件,不是你的代码。你得顺着十几行 required from 一路往回爬:stl_vector → stl_uninitialized → stl_construct,最后才意识到"哦,原来 std::thread 不能拷贝"。

⚠️ 一句话总结第一步的痛点:模板对类型几乎不设任何检查,可编译器把所有检查都拖到实例化那一刻,在错误深层才爆炸,报错又长又难定位。

第二步:requires 子句,给模板上把锁

C++ 的开发者想说:我能不能在模板"接活"之前,先声明一句"我只接受某种类型"?不满足条件的模板,编译器直接不编译它——报错自然就消失了。

这就有了 requires 子句。它是一个放在 template<…> 后面的"门槛",门槛里的布尔表达式为真,模板才被启用:

// C++20#include<iostream>#include<type_traits>// std::is_pointer_vtemplate<typename T>requires(!std::is_pointer_v<T>)// 门槛:T 不能是指针T maxValue(T a, T b){return b < a ? a : b;}intmain(){int x = 42, y = 77;    std::cout << maxValue(x, y) << '\n';        // OK:int 不是指针// maxValue(&x, &y);                        // ❌ 指针被挡在门外// std::cout << maxValue(&x, &y) << '\n';}

输出:

77

现在你传 &x、&y 进去,报错会变成这样(短到几乎不用滚动):

note: candidate: 'template<class T> requires (!std::is_pointer_v<T>)       T maxValue(T, T)'note:   constraints not satisfied

对比一下:

  • 第一步的报错:报错埋在库深处,你得顺着几十行堆栈往回找。
  • 第二步的报错:编译器的答复就一句话——constraints not satisfied(约束不满足)。它说的就是你,就在调用点,一行。

这套机制叫编译期检查:它只影响编译器"让不让你编译",对生成代码的性能是零开销。

第三步:定义概念,把约束打包成名字

requires (!std::is_pointer_v<T>) 能用,但有两个小别扭:

  1. 每次都要写这一长串 !std::is_pointer_v<T>,写两处就是两处重复。
  2. 报错信息里显示的是 !std::is_pointer_v<T>,读报错的人还得停下来翻译。

于是有了 concept(概念):给约束起个名字,像下面这样:

// C++20#include<iostream>#include<type_traits>// 定义一个概念:类型 T 满足"不是指针"template<typename T>concept NotPointer = !std::is_pointer_v<T>;template<typename T>requires NotPointer<T>T maxValue(T a, T b){return b < a ? a : b;}intmain(){    std::cout << maxValue(42, 77) << '\n';       // 正常:77// maxValue(42, "hello");                    // ❌ 报错里直接显示概念名 NotPointer}

输出:

77

定义概念的标准姿势:template<typename T> concept 名字 = 编译期布尔表达式;。

等号右边是一个编译时求值的布尔表达式——类型特征(std::is_pointer_v<T> 等,可判断指针类型)在这里派上了大用场。概念本质就是"一个带名字的编译期条件"。

好处立刻显现:

  • 可复用——同一个约束想挂几个模板就挂几个,写一处。
  • 报错可读——现在报错信息里能看到的是 NotPointer 这个有语义的名字,而不是一串符号。

第四步:类型约束与重载,概念的完整形态

如果概念只是"给布尔表达式起名字",那还不算质变。它真正的威力在于:概念可以直接当类型约束用,还能参与重载。

4.1 概念当类型约束

写 template<NotPointer T>,就等价于在模板参数上直接挂条件,省掉 requires 那一行:

// C++20template<typename T> requires NotPointer<T>   // 等价于↓template<NotPointer T>                        // 概念直接当"类型的门槛"T maxValue(T a, T b);

记法上,NotPointer T 紧挨着模板参数,读作"T 必须满足 NotPointer 这个类型约束"。

4.2 概念重载:一个问题,两套实现

概念更妙的地方是可以参与重载:同一个 maxValue,给指针和非指针各写一个版本,编译器按约束自动挑。

不约束指针版和约束指针版写出两个重载:

// C++20#include<iostream>#include<type_traits>template<typename T>concept NotPointer = !std::is_pointer_v<T>;template<typename T>concept IsPointer = std::is_pointer_v<T>;// 非指针版本:直接比大小template<typename T>requires NotPointer<T>T maxValue(T a, T b){return b < a ? a : b;          // 比的是值}// 指针版本:比指针指向的值template<typename T>requires IsPointer<T>automaxValue(T a, T b){          // auto:返回解引用后的比较结果returnmaxValue(*a, *b);       // 解引用后再比一遍}intmain(){int x = 42, y = 77;    std::cout << maxValue(x, y) << '\n';       // 值版:77int px = 3, py = 5;    std::cout << maxValue(&px, &py) << '\n';   // 指针版:解引用比出 5    std::cout << maxValue(&x, &y) << '\n';     // 指针版→落到值版}

输出:

77577

看懂这段,你其实已经掌握了 concepts 的核心心智模型:

  1. 两个同名的 maxValue 并存,一个约束 NotPointer,一个约束 IsPointer。
  2. 传 int → 只有非指针版本满足约束 → 自动选用。
  3. 传 int* → 指针版本启用,它把两个指针解引用,再递归调用非指针版本——于是 maxValue(&x, &y) 终于比出了"指向的值" 77,而不是天知地知的地址。

对比第一步的"野模板":不设防时指针版本压根不存在,maxValue(&x, &y) 只能编译却比地址;有了概念约束后,编译器在编译期就替你想好了选哪套实现。报错的隐患,从"运行期才暴露"提前到了"编译期拦下"。

为什么说概念是"编译期要求"?

我们把这句话拆开看:

  • 模板写的 template<typename T>,意思是我"接受任意类型"——这是一种占位。
  • concepts 写的 template<IsPointer T>,意思是我"只接受满足 IsPointer 的类型"——这是一种要求。

C++20 里这两件事拼成泛型的完整表达力:

管什么
像什么
auto
 占位符
参数是"任意类型",让函数模板化
一张白纸,什么都能写
concept 概念
参数是"满足某条件的类型"
白纸上画了个框,只收框内的

概念不是一个新的"类型系统",它是在说:模板参数的类型当不了运行时参数,但能在编译期被"审查"。 审查通过才让编译,审查不过就给你一句清楚的 constraints not satisfied。

报错,从几千行实例化堆栈,变成一行能看懂的人话——这就是概念存在的全部理由。

总结

  1. 痛点先行:裸模板零检查,报错埋在标准库深处,几十上百行堆栈——这是 concepts 想解决的核心问题。
  2. 四步演进:裸模板 → requires 子句(上锁)→ 定义 concept(给约束起名、可复用)→ 概念重载与类型约束(收放自如)。
  3. 概念是编译期要求:template<NotPointer T> 里的概念是类型约束,编译期审查,运行时零开销。
  4. 概念能重载:指针/非指针各写一套实现,编译器按约束自动挑,错误从用户代码提前到编译期。

公众号:我爱C嘎嘎 · 每天一个 C++ 新特性,2 分钟读完。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料