使用非类型模板参数的 C++20 概念对类模板进行完全专业化

Question

我对 C++20 概念相当陌生，我正在尝试创建一个模板类 Foo ，该类具有基于非类型（枚举器）模板参数的完全专门化的实现。我已经使用下面的代码测试了我的想法：

// Foo.h
#include <concepts>
#include <iostream>
#include <type_traits>

enum class Type { A, B, C };

template<std::is_enum T1, std::is_enum T2>
constexpr bool isEnumSame() { return T1 == T2; }

template<Type T> concept isTypeA = isEnumSame<T, Type::A>;
template<Type T> concept isTypeB = isEnumSame<T, Type::B>;

template<Type T>
struct Foo
{
   Foo() { std::cout << "Generic Foo\n"; }
};

template<Type T>
requires isTypeA<T>
struct Foo<T>
{
   Foo() { std::cout << "Type A Foo\n"; }
};

template<Type T>
requires isTypeB<T>
struct Foo<T>
{
   Foo() { std::cout << "Type B Foo\n"; }
};

// Foo.cpp
#include "Foo.h"

int main(void)
{
   Foo<Type::C> testC;
   Foo<Type::A> testA;
   Foo<Type::B> testB;

   return 0;
}

但是，我收到如下编译器错误（我使用 g++11 和 gcc11）：

error: insufficient contextual information to determine type
   27 |       Foo<Type::C> testC;

对于 Foo也有类似的错误。 testA 和 Foo测试B。有人可以告诉我我在这里可能做错了什么吗？另外，我理想情况下希望定义类似于以下内容的完整专业化：

template<isTypeA T>
struct Foo<T>
{
   Foo() { Print("Type A Foo"); }
};

但上面会产生编译器错误 error: 'isTypeA' does not constrain a type。任何帮助将不胜感激！

Answer 1

std::is_enum 不是一个概念，因此这个谓词不会执行我认为您认为它会执行的操作：

template<std::is_enum T1, std::is_enum T2>
constexpr bool isEnumSame() { return T1 == T2; }

您可以直接获取 Type 值。另外，您的概念行需要像这样调用函数：

template<Type T1, Type T2>
constexpr bool isEnumSame() { return T1 == T2; }

template<Type T> concept isTypeA = isEnumSame<T, Type::A>();
template<Type T> concept isTypeB = isEnumSame<T, Type::B>();

如果您希望 isEnumSame 对任何枚举都是通用的：

template <class T>
concept Enumeration = std::is_enum_v<T>;

template<Enumeration auto T1, Enumeration auto T2>
constexpr bool isEnumSame() { return T1 == T2; }

Answer 2

有几个问题：

1. 模板
   

   is_enum 是一个特征，而不是一个概念。您可以使用诸如auto T1之类的东西，然后requires std::is_enum_v。

2. 模板<类型T>概念 isTypeA = isEnumSame;`
   

   您忘记调用该函数，请添加 ()。

---

但你实际上并不需要任何这种概念魔法。您可以完全专门化 Foo 来获取枚举值：

template <>
struct Foo<Type::A> {...};

如果您出于某种原因不想完全专门化，您可以这样做：

template <Type T>
requires (T == Type::A)
struct Foo<T> {...};

Answer 3

首先，std::is_enum不是一个概念，它只是一个普通的类，
因此像 template 这样的语法只是定义一个接受 std::is_enum，这不是您所期望的，并且不限制任何内容。

其次，bool isEnumSame()的模板参数不是类型，而是枚举值，因此应该定义为template。。

如果需要约束非类型模板参数的类型，可以使用 decltype 来获取其类型，然后使用 requires 表达式来约束它，如下所示：

enum class Type { A, B, C };

template<auto T1, auto T2>
  requires std::is_enum_v<decltype(T1)> && std::is_enum_v<decltype(T2)>
constexpr bool isEnumSame() { return T1 == T2; }

template<Type T> concept isTypeA = isEnumSame<T, Type::A>();
template<Type T> concept isTypeB = isEnumSame<T, Type::B>();

演示