【ChatGPT教我编程】C++20 std::require

在 C++20 中，std::require 是一个 constexpr 函数模板，用于在编译时检查某个表达式的真假值。如果表达式为真，则该函数返回一个无意义的类型 void_t；否则编译会失败，出现相应的错误信息。

std::require 的定义如下：

c++Copy codetemplate <bool B, typename T = void>
struct enable_if {};

template <typename T>
struct enable_if<true, T> {
  using type = T;
};

template <bool B, typename T = void>
using enable_if_t = typename enable_if<B, T>::type;

template <typename T>
using void_t = enable_if_t<std::is_void<T>::value, void>;

template <bool B, typename T = void>
constexpr auto require = enable_if_t<B, T>{};

例如，考虑以下函数模板：

c++Copy codetemplate <typename T>
constexpr void foo(T val) {
  static_assert(std::is_integral<T>::value, "T must be integral");
  static_assert(std::require<sizeof(T) <= 4>, "T must be no larger than 4 bytes");
  // ...
}

在调用 foo 时，编译器会检查模板参数 T 是否为整数类型，以及其大小是否不超过 4 个字节。如果检查失败，编译会在此处出现相应的错误信息，不会继续编译后面的代码。

需要注意的是，std::require 是 C++20 中新增的特性，在早期的 C++ 标准中并不存在。因此，在使用该特性时需要确保编译器支持 C++20 标准。

std::require举几个复杂的例子

很抱歉，C++标准库中没有std::require这个函数，可能您想说的是std::require_concept，它是C++20中的一个概念（concept）工具，用于在编译时检查类型是否符合某种概念。这里举几个使用std::require_concept的例子：

1. 使用std::require_concept检查函数参数类型

下面的代码演示了如何使用std::require_concept检查函数参数类型是否符合某种概念。在这个例子中，我们定义了一个名为printable的概念，要求类型T必须支持输出操作符<<。

c++Copy code#include <iostream>
#include <concepts>

template <typename T>
concept printable = requires(T t) {
    std::cout << t;
};

void print(printable auto&& x) {
    std::cout << x << std::endl;
}

int main() {
    int i = 42;
    print(i);  // OK，int类型支持输出
    std::string s = "hello";
    print(s);  // OK，std::string类型支持输出
    std::pair<int, int> p = {1, 2};
    print(p);  // 编译错误，std::pair类型不支持输出
    return 0;
}

1. 使用std::require_concept作为模板类型参数的限定条件

下面的代码演示了如何使用std::require_concept作为模板类型参数的限定条件。在这个例子中，我们定义了一个名为MyClass的类模板，要求类型T必须支持相等比较操作符==，并且要求类型T还必须支持输出操作符<<。

c++Copy code#include <iostream>
#include <concepts>

template <typename T>
concept printable = requires(T t) {
    std::cout << t;
};

template <typename T>
concept my_class = requires(T t) {
    {t == t} -> std::same_as<bool>;
} && printable<T>;  // T必须支持相等比较和输出

template <my_class T>
class MyClass {
public:
    MyClass(const T& value) : value_(value) {}
    void print() {
        std::cout << value_ << std::endl;
    }
private:
    T value_;
};

int main() {
    MyClass<int> a(42);  // OK，int类型支持相等比较和输出
    a.print();
    // MyClass<std::string> b("hello");  // OK，std::string类型支持相等比较和输出
    // b.print();
    // MyClass<std::pair<int, int>> c({1, 2});  // 编译错误，std::pair类型不支持相等比较
    // c.print();
    return 0;
}

1. 使用std::require_concept作为模板类型参数的默认值

下面的代码演示了如何使用std::require_concept作为模板类型参数的默认值。在这个例子中，我们定义了一个名为MyClass的类模板，要求类型T必须支持相等比较操作符==，并且要求类型T还必须支持