ARTICLE · 1365649
模板报错像天文数字?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>) 能用,但有两个小别扭:
每次都要写这一长串 !std::is_pointer_v<T>,写两处就是两处重复。报错信息里显示的是 !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 的核心心智模型:
两个同名的 maxValue并存,一个约束NotPointer,一个约束IsPointer。传 int→ 只有非指针版本满足约束 → 自动选用。传 int*→ 指针版本启用,它把两个指针解引用,再递归调用非指针版本——于是maxValue(&x, &y)终于比出了"指向的值" 77,而不是天知地知的地址。
对比第一步的"野模板":不设防时指针版本压根不存在,maxValue(&x, &y) 只能编译却比地址;有了概念约束后,编译器在编译期就替你想好了选哪套实现。报错的隐患,从"运行期才暴露"提前到了"编译期拦下"。
为什么说概念是"编译期要求"?
我们把这句话拆开看:
模板写的 template<typename T>,意思是我"接受任意类型"——这是一种占位。concepts 写的 template<IsPointer T>,意思是我"只接受满足 IsPointer 的类型"——这是一种要求。
C++20 里这两件事拼成泛型的完整表达力:
auto | ||
概念不是一个新的"类型系统",它是在说:模板参数的类型当不了运行时参数,但能在编译期被"审查"。 审查通过才让编译,审查不过就给你一句清楚的 constraints not satisfied。
报错,从几千行实例化堆栈,变成一行能看懂的人话——这就是概念存在的全部理由。
总结
痛点先行:裸模板零检查,报错埋在标准库深处,几十上百行堆栈——这是 concepts 想解决的核心问题。 四步演进:裸模板 → requires子句(上锁)→ 定义 concept(给约束起名、可复用)→ 概念重载与类型约束(收放自如)。概念是编译期要求: template<NotPointer T>里的概念是类型约束,编译期审查,运行时零开销。概念能重载:指针/非指针各写一套实现,编译器按约束自动挑,错误从用户代码提前到编译期。
公众号:我爱C嘎嘎 · 每天一个 C++ 新特性,2 分钟读完。
















































































