concept输入模板参数，输出一个bool类型字面量。
例如：
auto is_int = std::integral<int>;
std::cout << "The type of std::integral<int> : " << type_to_string<decltype(std::integral<int>)>() << std::endl;
std::cout << "The value type of std::integral<int> : " << type_to_string<decltype((std::integral<int>))>()
<< std::endl;
输出：
The type of std::integral<int> : bool
The value type of std::integral<int> : bool
concept最后输出的结果的值类型是个纯右值，也就是个字面量。我们可以将concept的结果当成字面量使用，也可以用字面量替代concept的结果，在requires中使用。
concept结果当字面量用例如，输入输出：
auto is_int = std::integral<int>;
std::cout << std::boolalpha;
std::cout << "is_int : " << is_int << std::endl;
输出：
is_int : true
字面量当concept用
template<typename T>
requires true
void g(T a) {
std::cout << a << std::endl;
}
int main() {
g(10);
}
输出：
10requires
requires分两种，一种是在template下面的，用来判断concept是否满足的，例如下面的例子：
template<typename T>
requires std::integral<T>
void g(T a) {
std::cout << a << std::endl;
}
一种是带表达式的，和一个函数形式类似，例如：
template<typename T>
concept can_exec = requires(T a) {
a;
};
int main() {
std::cout << std::boolalpha;
std::cout << can_exec<int> << std::endl;
std::cout << can_exec<float> << std::endl;
}
输出：
true
false
其中：
requires(T a) {
a;
};
并不实际求值，只是判断{}内的表达式能否运行。再看个例子：
template<typename T>
concept can_exec1 = requires(T a) {
false;
};
int main() {
std::cout << std::boolalpha;
std::cout << can_exec1<int> << std::endl;
std::cout << can_exec1<float> << std::endl;
}
输出：
true
true
所以，对于requires(...){}来说，只要{}中的表达式能运行，就会返回真。
int main() {
auto can_exec2 = requires(int a, int b){
a b;
};
std::cout << std::boolalpha;
std::cout << can_exec2 << std::endl;
}
输出：
true
requires(...){}主要用来判断表达式能否运行，返回一个bool字面量
当然，也可以直接在template中运用
template<typename T>
requires
requires{
false;
}
void g1(T a) {
std::cout << a << std::endl;
}
g1(10)
输出：
10
requires表达式中还可以再嵌套第一种requires
如果直接使用，会报错：
// int main() {
// auto can_exec2 = requires std::integral<int>;
// std::cout << std::boolalpha;
// std::cout << can_exec2 << std::endl;
// }
// error: expected '{' before 'std'
int main() {
auto can_exec2 =requires{
requires std::integral<int>;
};
std::cout << std::boolalpha;
std::cout << can_exec2 << std::endl;
}
输出：
true
还可以这样用
int main() {
float a = 2.2;
int b = 3;
auto f = [&]<typename T>(T a) {
auto can_exec2 = requires(T value) { requires std::integral<T>; };
return can_exec2;
};
std::cout << std::boolalpha;
std::cout << f(a) << std::endl;
std::cout << f(b) << std::endl;
}
这样用：
template <typename T>
requires requires { requires std::integral<int>; }
void g1(T a) { std::cout << a << std::endl; }
用来约束lambda表达式
auto f = [&]<typename T>requires std::integral<T>(T a) {
};
