`test.cpp(47): error C2672: 'in': no matching overloaded function found`
`test.cpp(47): error C7602: 'in': the associated constraints are not satisfied`
`test.cpp(34): note: see declaration of 'in'`
随着编译器的改进，概念在出错信息上的优势在消减，但在代码表达上的优势仍然是实实在在的。记得[[第 14 讲]](https://time.geekbang.org/column/article/181636) 里我们费了好大的劲、用了几种不同的方法来定义 `has_reserve` 吗？在概念面前，那些就成了“回”字有几种写法了。我们可以飞快地定义下面的概念：
```
template <typename T>
concept has_reserve =
requires(T& dest) {
dest.reserve(1U);
};
```
这个概念用在编译期条件语句里，效果和之前的完全相同……哦，错了，不用再写 `::value` 或 `{}` 了😂。
在[[第 13 讲]](https://time.geekbang.org/column/article/181608) 我给出过的 `fmap`，在实际代码中我也是用了 SFINAE 来进行约束的（略简化）：
```
template <
template <typename, typename>
class OutContainer = vector,
typename F, class R>
auto fmap(F&& f, R&& inputs)
-> decltype(
begin(inputs),
end(inputs),
OutContainer<decay_t<
decltype(f(*begin(
inputs)))>>());
```
我费了老大的劲，要把返回值写出来，实际上就是为了利用 SFINAE 而已。如果使用“概念”，那代码可以简化成：
```
template <
template <typename, typename>
class OutContainer = vector,
typename F, class R>
requires requires(R&& r) {
begin(r);
end(r);
}
auto fmap(F&& f, R&& inputs);
```
上面的 `requires requires` 不是错误，正如 `noexcept(noexcept(…))` 不是错误一样。第一个 `requires` 开始一个 **requires 子句**，后面跟一个常量表达式，结果的真假表示是否满足了模板的约束条件。第二个 `requires` 则开始了一个 **requires 表达式**：如果类型 `R` 满足约束——可以使用 `begin` 和 `end` 对 `R&&` 类型的变量进行调用——则返回真，否则返回假。
不过，在 C++20 里，上面这个条件我是不需要这么写出来的。有一个现成的概念可用，这么写就行了：
```
template <
template <typename, typename>
class OutContainer = vector,
typename F, class R>
requires range<R>
auto fmap(F&& f, R&& inputs);
```
如你所见，我今天第二次用了 `range` 这个概念。究竟什么是 range？我们留到下一讲再说。
## 内容小结
今天我们讨论了 C++20 里可以说是最重要的新功能——概念。概念可以用来对模板参数进行约束，能取代 SFINAE，产生更好、更可读的代码。
注意本讲的内容并非一个形式化的描述，请你在阅读了本讲的内容之后，再对照参考资料 [6] 的内容看一下更严格的描述，然后再回过头来读一下例子，来加深你对本讲内容的理解。
## 课后思考
请结合自己的 C++ 项目，考虑一下，“概念”可以为开发具体带来哪些好处？反过来，负面的影响又可能会是什么？
## 参考资料
[1] Bjarne Stroustrup, “Concepts: the future of generic programming, or how to design good concepts and use them well”. [http://www.stroustrup.com/good_concepts.pdf](http://www.stroustrup.com/good_concepts.pdf)
[2] Alexander Stepanov and Paul McJones, **Elements of Programming**. Addison-Wesley, 2009. 有中文版（裘宗燕译《编程原本》，人民邮电出版社，2019 年）
[3] ISO/IEC JTC1 SC22 WG21, N4549, “Programming languages — C++ extensions for concepts”. [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4549.pdf](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4549.pdf)
[4] Herb Sutter et al., “Rename concepts to standard_case for C++20, while we still can”. [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1754r1.pdf](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1754r1.pdf)
[5] cppreference.com, “Standard library header <concepts>”. [https://en.cppreference.com/w/cpp/header/concepts](https://en.cppreference.com/w/cpp/header/concepts).
[5a] cppreference.com, “标准库头文件 <concepts>”. [https://zh.cppreference.com/w/cpp/header/concepts](https://zh.cppreference.com/w/cpp/header/concepts).
[6] Casey Carter et al., cmcstl2. [https://github.com/CaseyCarter/cmcstl2](https://github.com/CaseyCarter/cmcstl2)
[7] cppreference.com, “Constraints and concepts”. [https://en.cppreference.com/w/cpp/language/constraints](https://en.cppreference.com/w/cpp/language/constraints)
[7a] cppreference.com, “约束与概念”. [https://zh.cppreference.com/w/cpp/language/constraints](https://zh.cppreference.com/w/cpp/language/constraints)
[8] cppreference.com, “std::enable_if”. [https://en.cppreference.com/w/cpp/types/enable_if](https://en.cppreference.com/w/cpp/types/enable_if)
[8a] cppreference.com, “std::enable_if”. [https://zh.cppreference.com/w/cpp/types/enable_if](https://zh.cppreference.com/w/cpp/types/enable_if)
[9] Andrew Sutton, “Introducing concepts”. [https://accu.org/index.php/journals/2157](https://accu.org/index.php/journals/2157)
我们从下往上快速看一下：
- `move_constructible`：可移动构造
- `swappable`：可交换
- `movable`：可移动构造、可交换，合在一起就是可移动了
- `copy_constructible`：可拷贝构造
- `copyable`：可拷贝构造、可移动，合在一起就是可复制了（注：这儿“拷贝”和“复制”只是我在翻译中做的一点小区分，英文中没有区别）
- `default_initializable`：可默认初始化（名字不叫 `default_constructible` 是因为目前的 type traits 中有 `is_default_constructible`，且意义和 `default_initializable` 有点微妙的区别；详见[问题报告 3338](https://timsong-cpp.github.io/lwg-issues/3338)）
- `semiregular`：可复制、可默认初始化，合在一起就是半正则了
- `equality_comparable`：可相等比较，即对象之间可以使用 `==` 运算符
- `regular`：半正则、可相等比较，合在一起就是正则了
这些“概念”现在不只是文字描述，绝大部分是可以真正在代码中定义的。现在，准标准的定义已经可以在 cppreference.com 上找到 [5]。从实际的角度，下面我们列举部分概念在 CMCSTL2 [6]——一个 Ranges（我们下一讲讨论）的参考实现——中的定义。
从简单性的角度，我们自上往下看，首先是 `regular`：
```
template <class T>
concept regular =
semiregular<T> &&
equality_comparable<T>;
```
很简单吧，定义一个 concept 此处只是一些针对类型的条件而已。可以看出，每个概念测试表达式（如 `semiregular<T>`）的结果是一个布尔值（编译期常量）。
然后是 `semiregular`：
```
template <class T>
concept semiregular =
copyable<T> &&
default_initializable<T>;
```
再看一眼 `equality_comparable`：
```
template <class T, class U>
concept WeaklyEqualityComparable =
requires(
const remove_reference_t<T>& t,
const remove_reference_t<U>& u) {
{ t == u } -> boolean;
{ t != u } -> boolean;
{ u == t } -> boolean;
{ u != t } -> boolean;
};
template <class T>
concept equality_comparable =
WeaklyEqualityComparable<T, T>;
```
这个稍复杂点，用到了 `requires` [7]，但不需要我讲解，你也能看出来 `equality_comparable` 的要求就是类型的常左值引用之间允许进行 `==` 和 `!=` 的比较，且返回类型为布尔类型吧。
注意上面的定义里写的是 `boolean` 而不是 `bool`。这个概念定义不要求比较运算符的结果类型是 `bool`，而是可以用在需要布尔值的上下文中。自然，`boolean` 也是有定义的，但这个定义可能比你想象的复杂，我这儿就不写出来了😜。
我们之前已经讲过了各种迭代器，每个迭代器也自然地满足一个“概念”——概念名称基本上就是之前给的，只是大小写要变化一下而已。最底下的 `iterator` 是个例外：因为这个名字在标准里已经被占用啦。所以现在它的名字是 `input_or_output_iterator`。
迭代器本身需要满足哪些概念呢？我们看下图：
注意这张跟上面那张图不一样，概念之间不是简单的“合取”关系，而是一种“继承”关系：上面的概念比它指向的下面的概念有更多的要求。具体到代码：
```
template <class I>
concept weakly_incrementable =
semiregular<I> && requires(I i) {
typename iter_difference_t<I>;
requires signed_integral<
iter_difference_t<I>>;
{ ++i } -> same_as<I&>;
i++;
};
```
也就是说，`weakly_incrementable` 是 `semiregular` 再加一些额外的要求：
- `iter_difference_t<I>` 是一个类型
- `iter_difference_t<I>` 是一个有符号的整数类型
- `++i` 的结果跟 `I&` 是完全相同的类型
- 能够执行 `i++` 操作（不检查结果的类型）
`input_or_output_iterator` 也很简单：
```
template <class I>
concept input_or_output_iterator =
__dereferenceable<I&> &&
weakly_incrementable<I>;
```
就是要求可以解引用、可以执行 `++`、可以使用 `iter_difference_t` 提取迭代器的 `difference_type` 而已。
剩下的概念的定义也不复杂，我这儿就不一一讲解了。感兴趣的话你可以自己去看 CMCSTL2 的源代码。
### 简单的概念测试
为了让你再简单感受一下标准的概念，我写了下面这个简单的测试程序，展示一些标准概念的测试结果：
```
#include <armadillo>
#include <iostream>
#include <memory>
#include <type_traits>
using namespace std;
#if defined(__cpp_concepts)
#if __cpp_concepts < 201811
#include <experimental/ranges/concepts>
using namespace experimental::ranges;
#else
#include <concepts>
#endif
#else // defined(__cpp_concepts)
#error "No support for concepts!"
#endif
#define TEST_CONCEPT(Concept, \
Type) \
cout << #Concept << '<' << #Type \
<< ">: " \
<< Concept<Type> << endl
#define TEST_CONCEPT2( \
Concept, Type1, Type2) \
cout << #Concept << '<' \
<< #Type1 << ", " << #Type2 \
<< ">: " \
<< Concept<Type1, \
Type2> << endl
int main()
{
cout << boolalpha;
cout << "__cpp_concepts is "
<< __cpp_concepts << endl;
TEST_CONCEPT(regular, int);
TEST_CONCEPT(regular, char);
TEST_CONCEPT(integral, int);
TEST_CONCEPT(integral, char);
TEST_CONCEPT(readable, int);
TEST_CONCEPT(readable,
unique_ptr<int>);
TEST_CONCEPT2(
writable, unique_ptr<int>, int);
TEST_CONCEPT2(writable,
unique_ptr<int>,
double);
TEST_CONCEPT2(writable,
unique_ptr<int>,
int*);
TEST_CONCEPT(semiregular,
unique_ptr<int>);
TEST_CONCEPT(semiregular,
shared_ptr<int>);
TEST_CONCEPT(equality_comparable,
unique_ptr<int>);
TEST_CONCEPT(semiregular,
arma::imat);
TEST_CONCEPT2(assignable_from,
arma::imat&,
arma::imat&);
TEST_CONCEPT(semiregular,
arma::imat22);
TEST_CONCEPT2(assignable_from,
arma::imat22&,
arma::imat22&);
}
```
代码照顾了两种可能的环境：
- 最新的 MSVC（需要使用 `/std:c++latest`；我用的是 Visual Studio 2019 16.4.4）
- GCC（需要使用 `-fconcepts`；我测试了 7、8、9 三个版本都可以）和 CMCSTL2（需要将其 include 目录用 `-I` 选项加到命令行上）
程序在 MSVC 下的结果如下所示：
>