Wie überprüft man, ob zwei Typen aus der gleichen Template-Klasse stammen

Question

Ich möchte prüfen, ob zwei Typen gleich sind, aber unabhängig von ihren Template-Parametern. Etwas wie folgt aus:

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 
} 

Ich bin mir bewusst, std::is_same zu überprüfen, ob zwei Typen exacty entsprechen.

Ein Grund, warum ich das brauchen: Ich habe eine Templat-Methode, die mit jeder Art bezeichnet werden kann, aber ich möchte, dass verbieten, ist mit Art A (das Templat-) genannt wird, möglicherweise durch einen static_assert verwenden. Wurde A nicht als Templat, ich glaube, es leicht std::is_same mit getan werden könnte, aber jetzt, ich habe ein Problem ...

EDIT: ich manuell A für ein paar gemeinsamen Ts ausschließen kann, indem ich für eine Suche so, wie es für alle T zu tun:

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

okay, wie wäre es damit:

#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 
} 

Answer 2

ich mit einer einfacheren Art und Weise habe kommen als @ NikitaKakuev Antwort, verwendet zur Zeit auf einem project of mine.

Das einzige aktuelle Problem ist mit Vorlagen, die Typen und Typnamen mischen, dh. std::array<int, 10>.
Um diese Einschränkung zu überwinden, ist Spezialisierung erforderlich.

Verbrauch:

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

---

EDIT: Wie unten durch @Helix im Kommentar gebeten, Spezialisierung für std::array (oder jede andere Vorlage mit derselben Signatur):

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};