#include <iostream>

using namespace std;

template<template<int, int> class Comparer>
struct Test
{
    template<int T1, int T2>
    static void func( )
    {
        cout << Comparer<T1, T2>::result << endl;
    }
};


template<int T1, int T2>
struct Less
{
    enum { result = T1 < T2 };
};

struct Outer
{
    template<int T1, int T2>
    struct InternLess
    {
        enum { result = T1 < T2 };
    };
};

int main( )
{
    Test<Less>::func<30,20>( );              // OK
    Test<Outer::InternLess>::func<30,20>( ); // здесь падает с Internal Compiler Error
}

template<template<class,class> class Comparer>
struct Negator
{
    template<class T1, class T2>
    struct Negated
    {
        enum { result = !Comparer<T1, T2>::result };
    };
};

// Имеем Comparer<class,class>, хотим !Comparer<class,class> 
DoSomeWithComparer<Comparer>::doSome( );
DoSomeWithComparer<Negator<Comparer>::Negated>::doSome( );

WH>template<class T>
WH>typedef SomeTemplate<Type1, T, Type2> SomeElseTemplate;
WH>

template<class Type1, class Type2>
struct Bind13
{
    // Не совсем то же самое, что и выше, но в некоторых случаях поможет,
    // например, для передачи SomeTemplate в качестве параметра какому-нибудь шаблону
    // при зафиксированных 1 и 3 параметрах.
    template<class T>
    struct InternSomeElseTemplate : public SomeTemplate<Type1, T, Type2>
    { };
};
// И вместо SomeElseTemplate использовать MyBind::InternSomeElseTemplate,
// при typedef Bind13<Type1,Type2> MyBind;

#include <iostream>

using namespace std;

template<template<int, int> class Comparer>
struct Test
{
    template<int T1, int T2>
    static void func( )
    {
        typedef Comparer<T1, T2> Fix;
        cout << Fix::result << endl;
    }
};


template<int T1, int T2>
struct Less
{
    enum { result = T1 < T2 };
};

struct Outer
{
    template<int T1, int T2>
    struct InternLess
    {
        enum { result = T1 < T2 };
    };
};

int main( )
{
    Test<Less>::template func<30,20>();
    Test<typename Outer::InternLess>::template func<30,20>();
}

M> int main( )
M> {
M>     Test<Less>::template func<30,20>();
M>     Test<typename Outer::InternLess>::template func<30,20>();
M> }
M>

int main()
{
    Test<Less>::func<30,20>();
    Test<Outer::InternLess>::func<30,20>();
}

M>> int main( )
M>> {
M>>     Test<Less>::template func<30,20>();
M>>     Test<typename Outer::InternLess>::template func<30,20>();
M>> }
M>>

ПК>int main()
ПК>{
ПК>    Test<Less>::func<30,20>();
ПК>    Test<Outer::InternLess>::func<30,20>();
ПК>}
ПК>

14.2 Names of template specializations

[4] When the name of a member template specialization appears after . or ­> in a postfix expression,
or after nested name specifier in a qualified id, and the postfix expression or qualified id explicitly depends on a template parameter (14.6.2), the member template name must be prefixed by the keyword template. Otherwise the name is assumed to name a nontemplate.

class X
{
public:
    template<size_t> X* alloc();
    template<size_t> static X* adjust();
};

template<class T> void f(T* p)
{
    T* p1 = p->alloc<200>(); // illformed: < means less than
    T* p2 = p->template alloc<200>(); // OK: < starts template argument list
    T::adjust<100>(); // illformed: < means less than
    T::template adjust<100>(); // OK: < starts explicit qualification
}