#include <iostream>
using namespace std;

namespace test {

    template< typename... T >
    struct type_list {};

    template< template< typename... > class Template, typename... Arguments >
    type_list<Arguments...> deduce_template_arguments(Template<Arguments...>*);

    template< typename T >
    type_list<> deduce_template_arguments(T*);

    template< typename T >
    struct foo {
        using type = void;
    };

    template< typename Instance, typename ArgList, template< typename... > class Template, typename EnableIf = void >
    struct is_same_template_intern : public std::false_type
    {};

    template< typename Instance, typename... Args, template< typename... > class Template >
    struct is_same_template_intern<Instance, type_list<Args...>, Template, typename foo<Template<Args...>>::type >
    : public std::conditional< std::is_same< Instance, Template<Args...> >::value, std::true_type, std::false_type >::type
    {};

    template< typename Instance, template< typename... > class Template >
    struct is_same_template : public is_same_template_intern< Instance, decltype(deduce_template_arguments((Instance*)nullptr)), Template >
    {};

}

template< typename T >
struct test_struct {
};

template< typename T1, typename T2 >
struct test_struct2 {
};

int main()
{
    std::cout << test::is_same_template< test_struct<int>, test_struct >::value << "\n";
    std::cout << test::is_same_template< test_struct2<int,int>, test_struct >::value << "\n";
    std::cout << test::is_same_template< test_struct<int>, test_struct2 >::value << "\n";
    std::cout << test::is_same_template< test_struct2<int, int>, test_struct2 >::value << "\n";

    return 0;
}

ob ein Typ ein bestimmtes Template ist.

Du meinst, ob ein Typ eine Spezialisierung eines Templates ist. Das geht so:

#include <iostream>

template<typename T, template<typename...> class C>
struct is_specialization : std::false_type {};
template<template<typename...> class C, typename... Args>
struct is_specialization<C<Args...>, C> : std::true_type {};

template< typename T >
struct test_struct{};

template< typename T1, typename T2 >
struct test_struct2 {};

int main()
{
	static_assert(  is_specialization<test_struct<int>, test_struct>::value, "" );
	static_assert( !is_specialization<test_struct2<int, int>, test_struct>::value, "" );
	static_assert( !is_specialization<test_struct<int>, test_struct2>::value, "" );
	static_assert(  is_specialization<test_struct2<int, int>, test_struct2>::value, "" );
}

Allerdings ist das eine recht sinnlose Angelegenheit, da Templates drei verschiedene Arten von Parametern haben können, und das in allen Kombinationen. Daher lässt sich ein allgemeines Template dafür nicht schreiben.

ARGH. Arcoth war schneller und hat auch noch die elegantere Lösung.
Naja, ich tröste mich damit dass ich kaum TMP mache, speziell mit C++ 11 nicht

Ich brauch das nicht im Allgemeinen funktionabel, ich bastel mir hier nur gerade Options-Listen für Templates zusammen und in diese Liste klatscht man dann Options-Templates.

some_template< Foo, list<some_option<Arg1, Arg2>, other_option<Arg3>> > foo;

Das some_template-Template fischt sich dann einfach die Argumente aus der Options-Liste "get_nth_arg< List, some_option, 2, default_type>".