C++20 概念（Concepts）的使用
C++20 引入的 概念（Concepts）提供了一种新的机制，用于对模板参数进行约束。通过概念，模板编程变得更加可读、易于维护，同时可以为用户提供更有意义的编译错误信息。以下是概念在 C++20 中的使用方法，包括如何定义和使用概念。
1. 定义概念
概念定义的基本语法如下：
template <typename T>
concept ConceptName = /* 条件 */;
ConceptName是概念的名称。- 条件是一个布尔表达式，用于描述概念的要求。
示例：定义一个简单的概念
#include <concepts>
// 定义一个概念，要求类型 T 必须支持加法操作
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
在这个示例中，Addable 是一个概念，要求类型 T 必须支持加法操作，并且加法的结果可以转换为 T 类型。
2. 使用概念约束模板
概念可以用于约束模板参数，确保模板仅接受满足概念要求的类型。
示例：使用概念约束模板
#include <iostream>
#include <concepts>
// 定义一个概念，要求类型 T 必须支持加法操作
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
// 使用概念约束模板
template <Addable T>
T add(T a, T b) {
return a + b;
}
int main() {
std::cout << add(5, 3) << std::endl; // 合法，int 满足 Addable 概念
// std::cout << add("hello", "world") << std::endl; // 不合法，const char* 不满足 Addable 概念
return 0;
}
在这个示例中，add 函数模板被约束为仅接受满足 Addable 概念的类型。如果类型不符合概念要求，则会导致编译错误。
3. 概念的组合
概念可以组合使用，以创建更复杂的类型要求。
示例：组合多个概念
#include <iostream>
#include <concepts>
// 定义一个概念，要求类型 T 支持加法操作
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
// 定义一个概念，要求类型 T 支持减法操作
template <typename T>
concept Subtractable = requires(T a, T b) {
{ a - b } -> std::convertible_to<T>;
};
// 定义一个组合概念，要求类型 T 既支持加法又支持减法
template <typename T>
concept Arithmetic = Addable<T> && Subtractable<T>;
// 使用组合概念约束模板
template <Arithmetic T>
T compute(T a, T b) {
return a + b - b; // 示例操作
}
int main() {
std::cout << compute(10, 5) << std::endl; // 合法，int 满足 Arithmetic 概念
// std::cout << compute("hello", "world") << std::endl; // 不合法，const char* 不满足 Arithmetic 概念
return 0;
}
在这个示例中，Arithmetic 是一个组合概念，要求类型 T 既支持加法操作又支持减法操作。compute 函数模板被约束为仅接受满足 Arithmetic 概念的类型。
4. 概念的模板参数
概念不仅可以用于约束函数模板，还可以用于约束类模板的参数。
示例：约束类模板的参数
#include <iostream>
#include <concepts>
// 定义一个概念，要求类型 T 支持加法操作
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
// 使用概念约束类模板
template <Addable T>
class Adder {
public:
Adder(T x, T y) : a(x), b(y) {}
T add() const {
return a + b;
}
private:
T a, b;
};
int main() {
Adder<int> intAdder(5, 3);
std::cout << intAdder.add() << std::endl; // 合法，int 满足 Addable 概念
// Adder<std::string> strAdder("hello", "world"); // 不合法，std::string 不满足 Addable 概念
return 0;
}
在这个示例中，Adder 类模板被约束为仅接受满足 Addable 概念的类型。
5. 概念与 SFINAE 的对比
在 C++20 之前，SFINAE 是常用于模板参数约束的技术。概念是对 SFINAE 的一种改进，使得模板的约束条件更加直观。
示例：概念与 SFINAE 的对比
#include <iostream>
#include <type_traits>
// 使用 SFINAE 约束模板
template <typename T>
auto add(T a, T b) -> std::enable_if_t<std::is_integral_v<T>, T> {
return a + b;
}
// 使用概念约束模板
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
template <Addable T>
T add(T a, T b) {
return a + b;
}
int main() {
std::cout << add(1, 2) << std::endl; // 合法
// std::cout << add(1.5, 2.5) << std::endl; // 不合法，double 不满足 Addable 概念
return 0;
}
在这个示例中，SFINAE 约束的 add 函数模板通过 std::enable_if_t 实现，而概念的 add 函数模板则更加简洁和直观。
6. 总结
C++20 的概念（Concepts）为模板编程引入了强大的类型约束机制，使得模板代码更加清晰、易于维护，并且可以提供更有意义的编译错误信息。通过概念，开发者可以明确指定模板参数的要求，并利用概念组合来创建复杂的约束条件，从而提高代码的可读性和健壮性。