如何检查两种类型是否来自同一个模板类[重复]

Question

我想检查两种类型是否相同，但不管它们的模板参数如何。像这样的：

template<class T>
class A {};
class B {};

int main() {
    cout << std::is_same_template<A<int>, A<string>>::value << endl; // true
    cout << std::is_same_template<A<int>, B>::value << endl; // false
}

我知道std::is_same 用于检查两种类型是否完全匹配。

我需要这个的原因： 我有一个可以使用任何类型调用的模板化方法，但我想禁止使用A（模板化）类型调用它，可能使用static_assert。如果A 没有模板化，我相信使用std::is_same 可以轻松完成，但是现在，我有一个问题......

编辑： 我可以为一些常见的 T 手动排除 A，使用，我正在寻找一种方法来为所有 T 执行此操作：

static_assert(!std::is_same<parameter_type, A<int>>::value, "Cannot use this function with type A<T>");
static_assert(!std::is_same<parameter_type, A<double>>::value, "Cannot use this function with type A<T>");
static_assert(!std::is_same<parameter_type, A<bool>>::value, "Cannot use this function with type A<T>");

Answer 1

我想出了一个比@NikitaKakuev 的答案更简单的方法，目前用于project of mine。

template<typename, typename>
constexpr bool is_same_template{false};

template<
    template<typename...> class T, //typename T in C++17
    typename... A,
    typename... B
>
constexpr bool is_same_template<
    T<A...>,
    T<B...>
>{true};

当前唯一的问题是混合类型和类型名的模板，即。 std::array<int, 10>.
为了克服这个限制，需要专业化。

用法：

bool b = is_same_template<std::string, std::wstring>;  //true
//both are typedefs of std::basic_string

---

编辑：根据@Helix 在下面评论中的要求，专门针对std::array（或具有相同签名的任何其他模板）：

template<
    template<typename, std::size_t> class T, //typename T in C++17
    typename TA, std::size_t NA,
    typename TB, std::size_t NB
>
constexpr bool is_same_template<
    T<TA, NA>,
    T<TB, NB>
>{true};

Answer 2

好的，这个怎么样：

#include <iostream>

template<class T>
struct A {};
struct B {};

template <typename T>
struct should_reject { static constexpr bool value = false; };

template <typename T>
struct should_reject<A<T>> { static constexpr bool value = true; };

template <typename T>
void rejectA(T t)
{
    std::cout << should_reject<T>::value << std::endl;
}

int main() {
    rejectA(B());         // false
    rejectA(1);           // false
    rejectA(1.0);         // false
    rejectA(A<B>());      // true
    rejectA(A<int>());    // true
    rejectA(A<double>()); // true
}