<blockquote>C++20 Concepts通过引入声明式约束，使模板参数的条件更明确，提升了泛型编程的安全性、可读性和错误提示清晰度，相比SFINAE大幅改善了编译错误信息，并支持通过concept定义和组合约束，实现更直观的类型检查与更简洁的模板语法。</blockquote>
<p><img src="https://img.php.cn/upload/article/000/969/633/175574532956764.png" alt="c++模板约束concepts c++20新特性实践"></p>
<p>C++20的Concepts（概念）是给模板参数加上限制的<a style="color:#f60; text-decoration:underline;" title="工具" href="https://www.php.cn/zt/16887.html" target="_blank">工具</a>，它让你可以明确地表达模板参数需要满足哪些条件，比如它必须是可调用对象，或者它必须支持某个操作符。这样一来，编译器就能在更早的阶段捕获错误，给出的错误信息也清晰得多，不再是SFINAE时代那种让人头大的错误瀑布。简单来说，它让泛型编程变得更安全、更易读，也更容易调试。</p>
<h3>解决方案</h3>
<p>C++20 Concepts的实践，说白了就是学会如何定义和使用这些“约束”。你可以把Concepts想象成一套规则，任何试图使用你模板的代码，都得先通过这些规则的检查。</p>
<p>最直接的使用方式，是在模板声明中使用<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>子句。比如，你想要一个函数模板只能接受能被打印到<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::ostream</pre>
登录后复制
</div>的类型：</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>#include <iostream>
#include <string>
#include <concepts> // C++20 Concepts头文件
// 这是一个简单的requires子句示例
template<typename T>
requires requires(T value) { std::cout << value; } // 要求T类型的value能被输出到cout
void print_value(const T& value) {
std::cout << "打印值: " << value << std::endl;
}
// 也可以定义一个具名的Concept，让代码更清晰
template<typename T>
concept Printable = requires(T value) {
std::cout << value; // 要求T类型能通过operator<<输出到std::cout
};
template<Printable T> // 直接在模板参数列表里使用Concept，更简洁
void print_value_v2(const T& value) {
std::cout << "打印值 (v2): " << value << std::endl;
}
// 甚至可以约束auto参数
void print_value_v3(Printable auto value) { // 约束auto参数
std::cout << "打印值 (v3): " << value << std::endl;
}
// 结合多个约束
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>; // 要求是整数或浮点数
template<Numeric T>
void process_numeric(T value) {
std::cout << "处理数值: " << value * 2 << std::endl;
}
int main() {
print_value(123);
print_value("Hello Concepts");
print_value(3.14);
print_value_v2(456);
print_value_v2(std::string("你好，Concepts！"));
print_value_v3(789);
process_numeric(10);
process_numeric(2.5f);
// 下面这行会编译失败，因为std::string不是Numeric
// process_numeric(std::string("not a number")); // 编译器会给出清晰的错误信息
return 0;
}</pre>
登录后复制
</div><p>从上面的例子可以看出，<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>关键字是核心。它可以直接跟在模板参数列表后面，也可以用来定义独立的<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">concept</pre>
登录后复制
</div>。当定义了<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">concept</pre>
登录后复制
</div>后，你甚至可以直接在模板参数列表里使用它，比如<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">template<Printable T></pre>
登录后复制
</div>，这让代码读起来更像自然语言，一眼就能看出这个模板参数需要满足什么条件。</p>
<p><span>立即学习</span>“<a href="https://pan.quark.cn/s/6e7abc4abb9f" style="text-decoration: underline !important; color: blue; font-weight: bolder;" rel="nofollow" target="_blank">C++免费学习笔记（深入）</a>”；</p>
<p>刚开始接触Concepts的时候，我其实有点疑惑，这不就是SFINAE的语法糖吗？但用着用着，才发现它真的不仅仅是语法糖。它改变了我们思考泛型代码的方式，从“如果替换失败就不管”变成了“我明确要求你必须满足这些条件”。这种思维上的转变，带来的好处是巨大的。</p>
<h3>
<a style="color:#f60; text-decoration:underline;" title="为什么" href="https://www.php.cn/zt/92702.html" target="_blank">为什么</a>C++20 Concepts是泛型编程的重大飞跃？</h3>
<p>在C++20之前，我们为了约束模板参数，通常会依赖SFINAE（Substitution F<a style="color:#f60; text-decoration:underline;" title="ai" href="https://www.php.cn/zt/17539.html" target="_blank">ai</a>lure Is Not An Error）机制，或者使用一些复杂的元编程技巧。SFINAE就像是那种你得小心翼翼地绕过雷区，才能让代码编译通过的黑魔法。它能工作，但代价是<a style="color:#f60; text-decoration:underline;" title="代码可读性" href="https://www.php.cn/zt/55554.html" target="_blank">代码可读性</a>极差，而且一旦出错了，编译器抛出来的错误信息往往是天文数字般的模板实例化堆栈，让人完全摸不着头脑，调试起来简直是噩梦。</p>
<p>C++20 Concepts的出现，彻底改变了这种局面。它提供了一种声明式的、意图明确的方式来表达模板参数的约束。你不再需要通过巧妙地构造重载集或者依赖类型推导失败来“暗示”约束，而是可以直接说：“这个类型必须是可比较的”，或者“这个类型必须支持加法操作”。这种直接的表达方式，让代码变得异常清晰，就像给每个模板参数都贴上了详细的说明标签。这不仅仅是语法上的简化，更是对泛型编程范式的一次升级。它把原本隐晦的、通过编译器行为来推断的约束，提升到了语言层面，让它们成为了一等公民。这对于维护大型模板库或者编写复杂的泛型算法来说，简直是福音。</p>
<h3>C++20 Concepts如何提升模板错误消息的质量和代码可读性？</h3>
<p>我记得以前调试模板代码，最头疼的就是那一大串密密麻麻的<a style="color:#f60; text-decoration:underline;" title="编译错误" href="https://www.php.cn/zt/36569.html" target="_blank">编译错误</a>，简直是天书。当一个模板参数不满足某个隐性要求时，SFINAE机制会导致编译器尝试所有可能的模板重载，最终在替换失败时生成一大堆无关紧要的错误信息，真正的问题往往被淹没在其中。你可能需要花好几个小时去分析那些几十行甚至上百行的错误日志，才能找到真正导致编译失败的那个点。</p>
<p>而Concepts则彻底解决了这个问题。当一个类型不满足某个Concept的约束时，编译器会直接告诉你：“类型<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">X</pre>
登录后复制
</div>不满足<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">MyConcept</pre>
登录后复制
</div>，因为<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">MyConcept</pre>
登录后复制
</div>要求的<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">operator<<</pre>
登录后复制
</div>操作没有找到”，或者“<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::integral</pre>
登录后复制
</div>概念未满足”。这种错误信息是如此的直接和清晰，它精确地指出了哪个概念没有被满足，以及为什么没有满足。这就像是以前你掉进了迷宫，现在有人直接告诉你出口在哪里，甚至还画了地图。</p>
<p>从可读性上讲，<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">template<Printable T></pre>
登录后复制
</div> 或者 <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">void func(Addable auto value)</pre>
登录后复制
</div> 这样的写法，比 <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">template<typename T, typename = std::enable_if_t<std::is_invocable_v<decltype(std::declval<std::ostream&>() << std::declval<T>()), std::ostream&>>></pre>
登录后复制
</div> 这样的SFINAE表达式，简直是天壤之别。Concepts把复杂的约束逻辑封装在一个有意义的名字下面，让模板的签名本身就包含了其使用要求，极大地提升了代码的自文档性。任何人看到这样的代码，即使不深入了解实现细节，也能立即明白这个模板参数需要具备什么能力。这种清晰度，对于团队协作和代码维护来说，价值是无法估量的。</p>
<h3>实践：如何定义和组合自定义C++20 Concepts？</h3>
<p>定义自定义Concepts非常直观，通常使用<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">concept</pre>
登录后复制
</div>关键字。它后面跟着Concept的名称，然后是等号和<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>表达式。这个<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>表达式就是定义约束的核心。</p>
<div class="aritcle_card">
<a class="aritcle_card_img" href="/ai/2365">
<img src="https://img.php.cn/upload/ai_manual/001/246/273/176179450360677.png" alt="音秘AudioMyst">
</a>
<div class="aritcle_card_info">
<a href="/ai/2365">音秘AudioMyst</a>
<p>百度推出的AI播客创作工具</p>
<div class="">
<img src="/static/images/card_xiazai.png" alt="音秘AudioMyst">
<span>271</span>
</div>
</div>
<a href="/ai/2365" class="aritcle_card_btn">
<span>查看详情</span>
<img src="/static/images/cardxiayige-3.png" alt="音秘AudioMyst">
</a>
</div>
<p>我们来定义几个实用的自定义Concepts：</p>
<p><strong>1. <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">Printable</pre>
登录后复制
</div> Concept：</strong> 检查类型是否可以通过<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::ostream</pre>
登录后复制
</div>输出。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>#include <iostream>
#include <string>
#include <concepts>
// 定义一个Printable Concept
template<typename T>
concept Printable = requires(T value) {
{ std::cout << value } -> std::same_as<std::ostream&>; // 要求表达式能够编译，且返回类型是std::ostream&
};
// 使用Printable Concept的函数模板
template<Printable T>
void print_something(const T& item) {
std::cout << "打印项: " << item << std::endl;
}
// int和std::string都满足Printable
// print_something(123);
// print_something(std::string("Hello"));</pre>
登录后复制
</div><p>这里<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">{ std::cout << value } -> std::same_as<std::ostream&>;</pre>
登录后复制
</div> 是一个<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>表达式中的<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">compound requirement</pre>
登录后复制
</div>，它不仅检查表达式<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::cout << value</pre>
登录后复制
</div>是否有效，还检查其返回类型是否为<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::ostream&</pre>
登录后复制
</div>。</p>
<p><strong>2. <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">Addable</pre>
登录后复制
</div> Concept：</strong> 检查类型是否支持加法操作，并且加法结果的类型也是可预测的。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>// 定义一个Addable Concept
template<typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::same_as<T>; // 要求a+b操作有效，且结果类型与T相同
};
// 使用Addable Concept的函数模板
template<Addable T>
T add_two_items(const T& a, const T& b) {
return a + b;
}
// int和double都满足Addable
// add_two_items(5, 3);
// add_two_items(3.5, 2.1);</pre>
登录后复制
</div><p><strong>3. 组合Concepts：</strong> 你可以使用逻辑运算符<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">&&</pre>
登录后复制
</div>（AND）和<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">||</pre>
登录后复制
</div>（OR）来组合多个Concepts，形成更复杂的约束。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>// 定义一个Sortable Concept：要求类型是可比较的，并且可以交换
template<typename T>
concept Sortable = std::totally_ordered<T> && std::swappable<T>;
// 使用Sortable Concept的函数模板
// std::totally_ordered和std::swappable是C++标准库提供的Concepts
template<Sortable T>
void sort_element(T& a, T& b) {
if (a > b) {
std::swap(a, b);
}
}
// int类型满足Sortable
// int x = 5, y = 3;
// sort_element(x, y); // x变为3, y变为5</pre>
登录后复制
</div><p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::totally_ordered</pre>
登录后复制
</div>和<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::swappable</pre>
登录后复制
</div>是C++<a style="color:#f60; text-decoration:underline;" title="标准库" href="https://www.php.cn/zt/74427.html" target="_blank">标准库</a>中预定义的Concepts，它们分别检查类型是否支持所有比较运算符（<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;"><</pre>
登录后复制
</div>, <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;"><=</pre>
登录后复制
</div>, <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">></pre>
登录后复制
</div>, <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">>=</pre>
登录后复制
</div>, <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">==</pre>
登录后复制
</div>, <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">!=</pre>
登录后复制
</div>）以及是否可以通过<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">std::swap</pre>
登录后复制
</div>进行交换。</p>
<p>通过这些例子，你会发现定义和组合Concepts是多么的灵活和强大。它允许你以一种声明式、模块化的方式来构建复杂的类型约束，这对于设计健壮且易于理解的泛型库至关重要。</p>
<h3>实践：使用Concepts简化函数模板和Lambda表达式</h3>
<p>C++20的Concepts不仅仅是为<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">template<typename T></pre>
登录后复制
</div>这种传统模板参数提供约束，它还引入了一种更简洁的语法，特别是在函数模板和Lambda表达式中。这被称为“缩写函数模板”（Abbreviated Function Templates）和对<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">auto</pre>
登录后复制
</div>参数的约束。</p>
<p><strong>1. 缩写函数模板：</strong>
当你定义一个Concept后，你可以直接把它用在函数模板的参数列表中，取代<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">typename T</pre>
登录后复制
</div>或者<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">class T</pre>
登录后复制
</div>。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>#include <iostream>
#include <string>
#include <concepts>
// 再次定义Printable Concept
template<typename T>
concept Printable = requires(T value) {
{ std::cout << value } -> std::same_as<std::ostream&>;
};
// 传统的模板语法
template<typename T>
requires Printable<T>
void print_traditional(const T& value) {
std::cout << "传统打印: " << value << std::endl;
}
// 缩写函数模板语法：更简洁，更直接
template<Printable T> // 直接在模板参数列表里使用Concept
void print_abbreviated(const T& value) {
std::cout << "缩写打印: " << value << std::endl;
}
int main() {
print_traditional(100);
print_abbreviated("Hello from abbreviated!");
// print_abbreviated([](){}); // 编译错误，lambda不满足Printable
return 0;
}</pre>
登录后复制
</div><p>这种写法刚开始看有点不习惯，但写多了你就会发现，它把模板的冗余大大降低了，尤其是在写一些小型泛型工具函数时，简直是神器。它让模板参数的意图一目了然，不需要额外的<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">requires</pre>
登录后复制
</div>子句。</p>
<p><strong>2. 约束<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">auto</pre>
登录后复制
</div>参数：</strong>
在C++11引入<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">auto</pre>
登录后复制
</div>关键字作为函数参数类型（用于Lambda表达式）后，C++20允许你直接对这些<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">auto</pre>
登录后复制
</div>参数施加Concept约束。这使得泛型Lambda和泛型函数可以拥有更明确的类型要求。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:cpp;toolbar:false;'>#include <iostream>
#include <concepts>
// 假设我们有一个Numeric Concept
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
// 约束auto参数的函数
void process_constrained_auto(Numeric auto value) {
std::cout << "处理约束auto参数: " << value * 2 << std::endl;
}
// 约束auto参数的Lambda表达式
auto add_if_numeric = [](Numeric auto a, Numeric auto b) {
return a + b;
};
int main() {
process_constrained_auto(5);
process_constrained_auto(3.14);
// process_constrained_auto("hello"); // 编译错误，string不是Numeric
std::cout << "相加结果: " << add_if_numeric(10, 20) << std::endl;
std::cout << "相加结果: " << add_if_numeric(1.5, 2.5) << std::endl;
// add_if_numeric("a", "b"); // 编译错误
return 0;
}</pre>
登录后复制
</div><p>通过<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">Numeric auto value</pre>
登录后复制
</div>这样的语法，你不仅获得了<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false;">auto</pre>
登录后复制
</div>的简洁性，还同时确保了类型安全性。这对于编写小型、即时性的泛型代码，或者在现代C++库中提供灵活的API，都是非常有用的特性。它让泛型编程的门槛进一步降低，同时也保持了其固有的健壮性。</p>
以上就是C++模板约束concepts C++20新特性实践的详细内容，更多请关注php中文网其它相关文章！
广告
收藏
306
