C++20之Concpet（概念部分，之二）

原创已于 2023-01-30 11:01:29 修改 · 2.2k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#c++20 #c++ #开发语言

于 2022-09-28 13:53:32 首次发布

C++代码专栏收录该内容

38 篇文章

订阅专栏

本文深入探讨C++20中概念(concept)的高级应用，包括作为类型关键字、函数参数修饰符等新颖用法，并解析概念特化、重载及潜在问题。

先序文章请先看C++20之Concept（概念部分，之一）

concept的高级语法

上一篇我们介绍了concpet的概念，还有基本的用法。不过到目前为止，我们见到的只能算是concept的「正统」形式，怎么说呢，尽管concept作为C++20的四大颠覆性特性之一（甚至之首），但单从形式上来看，还是有些一板一眼了。

template <typename T>
requires SomeConditon<T>
struct ClassName {};

这种所谓的「标准形式」看上去还是很浓重的C++味道，它给人的感觉就是“嗯~这很C++”。经历过C++17洗礼的同学都知道，C++新标准很喜欢做的事情就是，发布一个看上去非常平平无奇的新特性，但稍微一展开、一组合，这个特性就爆炸了，让人拍案叫绝。同理，concept并不是只有这种标准用法，今天这篇我们就来让concept代码“飞起来~”

concept作为类型关键字使用

当一个concept恰好是修饰模板参数中的一个类型（而不是它的变体）时，concept可以直接作为类型关键字使用。这样描述可能不好理解，我们来看例子：

template <typename T>
concept Condi1 = std::is_trivial_v<T>; // 这是一个concept

template <typename T>
requires Condi1<T> // 这里concept直接作用于T，而不是类似于T *或者std::decay_t<T>之类的
struct Test {};

上面例子中，Test模板类需要一个concpet名为Condi1，它直接作用于模板参数T上，那么就可以改写成下面的形式：

template <Condi1 T>
struct Test {};

这就好像Condi1成为了一个类型关键字，理解为「符合Condi1定义的类型T」。

这里有一个需要注意的就是，如果作为类型关键字使用，那么它必须是一个concept定义，而不能是其他形式的静态布尔表达式，比如说：

template <std::is_trivial_v T> // ERR，因为std::is_trivial_v并不是concept定义
struct Test {};

不过遇到修饰模板参数的变体，或者存在复合约束的时候，那就只能去使用requires语句了，比如说：

template <typename T>
requires std::is_trivial_v<std::decay_t<T>> // 约束T的变体
struct Test1 {};

template <typename T>
requires std::is_trivial_v<T> && (sizeof(T) <= sizeof(void *)) // 复合约束
struct Test2 {};

当然，它本身和requires语句并不冲突，遇到一些复合约束的时候，两种语法可以共存，比如：

template <typename T>
concept Condi1 = std::is_trivial_v<T>;

template <typename T>
concept Condi2 = sizeof(std::decay_t<T>) < sizeof(void *);

template <Condi1 T1, typename T2>
requires Condi1<T2> && Condi2<T2>
struct Test {};

模板函数的concept

前面的章节我们都在介绍模板类使用concept的情况，但其实对于模板函数，还会有不一样的风景等着我们。

首先，模板函数仍然支持concept的标准形式，比如：

template <typename T>
requires std::is_trivial_v<T>
void f() {}

这种用法和模板类完全一致，不再赘述。那么当然它也支持用concept作为类型关键字的形式：

template <typename T>
concept Trivial = std::is_trivial_v<T>;

template <Trivial T>
void f() {}

但模板函数相比模板类，多了一种可以确定模板参数的途径，那就是参数类型自动推导。回忆一下，对于模板函数来说，编译器可以根据实参类型来推导出模板参数类型，比如说：

template <typename T, typename R>
void f(T t, R r) {}

void Demo() {
  f(1, 3.5); // 推导出f<int, double>
  f("abc", 6ul); // 推导出f<const char *, unsigned long>
}

而concept同样可以作为「参数类型」来修饰形参，比如：

template <typename T>
concept Trivial = std::is_trivial_v<std::decay_t<T>>;

void f(Trivial auto t, Trivial auto r) {}

void Demo() {
  f(1, 3.5); // 会推导出f<int, double>，再分别去检查Trivial<int>和Trivial<double>是否合理
  f('A', std::string("abc")); // ERR，首先推导出f<char, std::string &&>而因为Trivial<std::string>会返false，因此不允许这种实例化
}

这个语法着实是把concept玩飞了，至此我们甚至不需要template关键字就可以定义一个模板函数了。当然这么做的缺点就在于，可能不容易让人意识到这是一个模板函数，于是把声明和实现分散在.h和.cpp中，导致链接错误。所以这里着重强调：虽然这种语法没有出现template关键字，但它仍是模板，需要定义在头文件中！！

使用concept后可能会遇到的疑惑

至此我们基本将concept的概念和用法介绍完毕了。但正如我前面所说的，一个新特性本身可能没有太多东西，但和其他特性组合一下就可能会“爆炸”，所以本节主要介绍concept特性相关的可能会遇到的疑惑点。

模板特化

如果一个模板用了concept修饰，它还能不能被特化呢？答案是可以！concept本身不影响SFINAE的匹配原则，同样支持特化。但是必须有一个前提，就是说特化类型必须符合concept，否则不许特化，举例来说：

#include <concepts> // STL标准库提供了很多concept可以使用
template <std::integral T> // 要求T必须是整数
struct Test {};

template <>
struct Test<long> {}; // OK，对于long类型的特化

template <>
struct Test<std::string> {}; // ERR，因为std::string本身不符合std::integral，因此不可以特化

void Demo() {
  Test<int> t1; // 用通用模板进行实例化Test<int>
  Test<long> t2; // 会使用Test<long>的特化
}

而对于偏特化同样是允许的，但也是要符合concept的类型。比如：

template <std::integral T1, std::integral T2>
struct Test {};

template <typename T>
struct Test<int, T> {}; // 偏特化，OK

concept用作偏特化

我们可以定义用concept约束的偏特化。举例来说：

template <typename T>
struct Test {};

template <std::integral T>
struct Test<T> {};

void Demo() {
  Test<int> t1; // 由于int符合std::integral，因此用偏特化模板实例化Test<int>
  Test<std::string> t2; // 会用通用模板实例化Test<std::string>
}

在上面例子中，Test通用模板原本是没有被concept约束的，我们可以定义如果T符合“某些特性”的话，就使用一种特化。比如说上面就是当T符合std::integral时，使用下面的特化。因此，这里本质是也一种模板的偏特化。

需要注意的是，与其他偏特化一致，如果某种实例同时命中多个偏特化，却没有针对于这种类型的全特化模板时，将会报二义性错误：

template <typename T>
struct Test {};

template <std::integral T>
struct Test<T> {};

template <typename T>
requires (sizeof(T) == 1)
struct Test<T> {};

void Demo() {
  Test<int> t1;
  Test<std::string> t2;
  Test<char> t3; // Ambiguous partial specializations of 'Test<char>'
}

另一个要注意的是，偏特化必须要“更加特化”，也就是说偏特化后的范围应当比特化前的范围更窄，但并没有窄到只剩一种类型（不然就叫全特化了），例如：

template <std::integral T>
struct Test {};

template <std::unsigned_integral T> // 针对于无符号数的偏特化
struct Test<T> {};

首先，偏特化的约束必须包含通用模板中的约束，这里unsigned_integral表示无符号整数，而integral表示整数，显然有包含关系。当然了，这种包含关系并不是看出来的，而是要从定义上包含，我们看看unsigned_integral的定义就知道了：

template <typename T>
concept unsigned_integral = std::integral<T> && !std::signed_integral<T>;

因为unsigned_integral内部已经包含unsigned_integral了，所以才OK。但是如果你用的是两种不搭噶的concept，就会报错，比如说：

template <typename T>
requires (sizeof(T) <= 16)
struct Test {};

template <typename T>
requires (sizeof(T) <= 8)
struct Test<T> {}; // Class template partial specialization is not more specialized than the primary template

尽管这里，长度小于8确实是包含在长度小于16中了，但编译器不会做这种集合运算，你必须要显式定义出来才行，所以正确的做法是：

template <typename T>
concept Con1 = (sizeof(T) <= 16);

template <typename T>
concept Con2 = Con1<T> && (sizeof(T) <= 8); // 尽管包含Con1是句废话，但必须要写

template <Con1 T>
struct Test {};

template <Con2 T> 
struct Test<T> {}; // 因为Con2显式包含了Con1，所以才OK

注意这里是「显式」包含才可以，比如说下面这种就不可以：

template <typename T>
requires (sizeof(T) <= 16)
struct Test {};

template <typename T>
requires (sizeof(T) <= 16) && (sizeof(T) <= 8)
struct Test<T> {}; // 仍然不可以，因为没有「显式」包含

下面这种形式也算「显式」包含，所以也是OK的：

template <typename T>
concept Con1 = (sizeof(T) <= 16);

template <typename T>
requires Con1<T>
struct Test {};

template <typename T>
requires Con1<T> && (sizeof(T) <= 8) // 因为这里也显式用到Con1了，所以OK
struct Test<T> {};

通过这些例子就是希望读者能明白在利用concept进行偏特化时，如何才算符合「偏特化」要求。

函数重载

由于模板函数不能偏特化，因此也不会出现前一节出现的各种问题。不过函数是支持重载的，用concept修饰的模板函数并不影响函数重载，请看例程：

void f(std::integral auto t) {}
void f(int t) {} // OK
int f(double t) {return 0;} // OK

由于函数重载的优先级大于SFINAE匹配，因此这里的函数重载都是OK的。当然，它同样不影响模板全特化：

void f(std::integral auto t) {std::cout << 1 << std::endl;}
void f(int t) {std::cout << 2 << std::endl;}
template <>
void f<int>(int t) {std::cout << 3 << std::endl;}

void Demo() {
  f(1u); // 打印1
  f(1); // 打印2
  f<>(1); // 打印3
}

上面例子说明了函数重载优先级大于SFINAE，所以f(1)会调用重载函数。而显式添加了<>后，强制使用模板实例，再进行SFINAE时全特化优先级大于通用模板，所以会调用全特化实例。

总之这些都跟以前的模板没有任何变化，主要需要大家牢记的一点就是用concept修饰的函数虽然没有template关键字，但它依然是模板函数，其他的东西就都可以推出来了。

模板函数的“偏特化”

大家应该注意到了，我这里的“偏特化”是打双引号的。的确，C++20仍然是不允许模板函数的偏特化的，比如：

template <typename T, typename R>
void f2() {};

template <typename T>
void f2<T, int>() {} // Function template partial specialization is not allowed

但引入了concept之后，模板函数却可以支持「concept的偏特化」，请看例子：

void f(std::integral auto t) {std::cout << 1 << std::endl;}
void f(std::unsigned_integral auto t) {std::cout << 2 << std::endl;}

void Demo() {
  f(1); // 打印1
  f(1u); // 打印2
}

相信细心的读者应该已经发现了，其实这并不是「偏特化」，而是函数重载，所以这种情况下，并不要求按照前面章节所叙述的模板类的那种偏特化原理，即便两个concept是不包含的，也仍然能通过编译。

但是一定要注意，一旦某种类型同时命中多个模板函数，则会直接报二义性错误，比如：

template <typename T>
concept Small = sizeof(T) == 1;

void f(std::integral auto t) {std::cout << 1 << std::endl;}
void f(Small auto t) {std::cout << 2 << std::endl;}

void Demo() {
  f(1); // 打印1
  f('A'); // Call to 'f' is ambiguous
}