如果类模板将实例化，则变量模板为真？

Question

假设我有一个类模板 A，它有一个类型模板参数和一个主要特化：

 template<typename T> struct A {
    /*...*/
 };

对于某些T 参数A<T> 将成功实例化，而对于另一些则不会。

不修改或扩展A的定义，是否可以写一个bool变量模板：

template<typename T>
constexpr bool WorksWithA = /*...*/;

如果A<T> 实例化成功，那么WorkWithA<T> 为真？

更新

将此作为单独的问题发布：Using typename in C++20 requires / concept?

#include <iostream>

template<typename T>
struct A {
    using X = typename T::X;
};

template<typename T>
constexpr bool WorksWithA = requires { typename A<T>; };

struct GoodArg {
    using X = int;
};

struct BadArg {
};

int main() {
    std::cout << WorksWithA<GoodArg> << std::endl;
    std::cout << WorksWithA<BadArg> << std::endl;
}

编译并运行：

$ clang++ --version
clang version 10.0.0-4ubuntu1 
$ clang++ test.cc -std=c++20
$ ./a.out 
1
1

这输出1 1，预期输出是1 0？

什么给了？

Answer 1

如果我理解正确，对于 SFINAE 友好类型，这可能是一种方式：

如果可以实例化则匹配：

template<class T>
constexpr auto WorksWithA(int) -> A<T>;

如果不是则匹配：

struct no {};
template<class T>
constexpr auto WorksWithA(long) -> no;

助手：

template<typename T>
inline constexpr bool WorksWithA_v = 
    not std::is_same_v<no, decltype(WorksWithA<T>(0))>;

Demo

---

如果 A 对 SFINAE 不友好（如更新问题中的 A），您必须在 WorksWithA 中添加检查。在这种情况下：

template<typename T>
struct A {
    using X = typename T::X;
};

template<class T>
constexpr auto WorksWithA(int) -> typename T::X;

struct no {};
template<class T>
constexpr auto WorksWithA(long) -> no;

template<typename T>
inline constexpr bool WorksWithA_v =
    not std::is_same_v<no, decltype(WorksWithA<T>(0))>;

Demo

Answer 2

您误解了模板的工作原理。

template<typename T>
struct A {
    using X = typename T::X;
};

template<typename T>
constexpr bool WorksWithA = requires { typename A<T>; };

struct GoodArg {
    using X = int;
};

struct BadArg {
};

BadArg 基本上与 A 一起工作。还不错。

template<typename T>
struct A {
    using X = typename T::X;
};

这不要求T 有一个类型名X。

这表明如果它确实有一个类型名X，那么A::X就是那个类型名。

所以如果T 可以实例化模板A，WorksWithA 会正确测试。

这对您没有直接帮助，但了解您提出了错误的问题以及为什么您的问题是错误的问题很重要。因为这会引出正确的问题。

或者当T没有X类型时，你想要A不实例化，或者你想要WorksWithA做不同的类型测试。

例如，也许你想要HasAnX:

template<class T>
concept HasAnX = requires { typename T::X; };

然后

static_assert(HasAnX<GoodArg>);
static_assert(!HasAnX<BadArg>);

编译。

但是，我猜这在语义上与您希望它匹配的内容不匹配。您希望它是 A-ness 而不是您正在测量的 X-ness。

那么您的问题可能不是与WorksWithA 相关，而是A 本身。你以为你在哪里添加了THasAnX的要求，但你在哪里没有。

template<HasAnX T>
struct A {
    using X = typename T::X;
};

这使得A 要求T 有一个X。现在，WorksWithA ... 按您的预期工作。

Live example.

Answer 3

这是一个很好（也很正确）的问题，但我认为到目前为止，这个问题一般都没有答案。 让我们假设类模板A 就像：

template<typename T>
class A{
public:
    T variable;
}

这个模板适用于大多数类型，但它不使用T = void 进行实例化，原因很明显。现在让我们假设我们想通过 SFINAE 友好的方法提前找出答案。

判断一个类型是否可实例化的最好工具是检查它是否有大小，现在让我们定义一个类似于std::void_t的工具：

template<size_t...> using void_size_t = void;

现在如果我们定义：

template< class, class = void >
struct pre_WorksWithA : std::false_type { };

template< class T >
struct pre_WorksWithA<T, void_size_t<sizeof(A<T>)>> : std::true_type { };

template<typename T>
constexpr bool WorksWithA = pre_WorksWithA<T>::value;

对于像int 这样的普通类型，结果应该是true。但在void 的情况下，WorksWithA 和pre_WorksWithA 都不能实例化，结果将是编译器出错。

所以如您所见，到目前为止，C++ 中基本上没有任何特性可以帮助我们知道一个类型是否可以实例化而不报错？

Answer 4

你可以用一个简单的概念：

template<typename T>
constexpr bool WorksWithA = requires { typename A<T>; };