using namespace std;
using u1 = unsigned char;

template<typename T>struct TypeH;
using TypeH1 = TypeH<int>;
using TypeH2 = TypeH<char>;

template<typename T>
struct STest4
{
  template<typename H> void foo();// ключевой момент
  template<> void foo<TypeH1>(){ cout << "TypeH1" << endl; }
};
//template<>
template<typename T> void STest4<T>::foo<TypeH2>(){ cout << "TypeH2" << endl; }//error C2768: 'STest4<T>::foo': illegal use of explicit template arguments

int Test4()
{
  STest4<float> st4;
  st4.foo<TypeH1>();
  st4.foo<TypeH2>();
  return 0;
}

#include <iostream>

using namespace std;
using u1 = unsigned char;

template<typename T>struct TypeH;
using TypeH1 = TypeH<int>;
using TypeH2 = TypeH<char>;

template<typename T>
struct STest4
{
    //на концептах
    template<typename H> void foo() requires std::is_same_v<H, TypeH1>
    {
        cout << "TypeH1" << endl;
    }

    template<typename H> void foo() requires std::is_same_v<H, TypeH2>;

    //на SFINAE
    template<typename H> std::enable_if_t<std::is_same_v<H, TypeH1>> foo2()
    {
        cout << "TypeH1" << endl;
    }

    template<typename H> std::enable_if_t<std::is_same_v<H, TypeH2>>  foo2();
};

template<typename T>
template<typename H>
void STest4<T>::foo() requires std::is_same_v<H, TypeH2>
{
    cout << "TypeH1" << endl;
}

template<typename T>
template<typename H>
std::enable_if_t<std::is_same_v<H, TypeH2>> STest4<T>::foo2()
{
    cout << "TypeH2" << endl;
}

int Test4()
{
  STest4<float> st4;
  st4.foo<TypeH1>();
  st4.foo<TypeH2>();
  st4.foo2<TypeH1>();
  st4.foo2<TypeH2>();
  return 0;
}

template<typename T>
struct STest4
{
  template<typename H> STest4() requires is_same_v<H, TypeH1> { cout << "ctor(TypeH1)" << endl; }
  template<typename H> STest4() requires is_same_v<H, TypeH2> { cout << "ctor(TypeH2)" << endl; }
  ...
};

STest4<float> st5_1<TypeH1>();//warning C4930: 'STest4<float> st5_1(void)': prototyped function not called (was a variable definition intended?)
STest4<float> st5_2<TypeH2>();//warning C4930: 'STest4<float> st5_1(void)': prototyped function not called (was a variable definition intended?)

SVV>template<typename T>
SVV>struct STest4
SVV>{
SVV>  template<typename H> STest4() requires is_same_v<H, TypeH1> { cout << "ctor(TypeH1)" << endl; }
SVV>  template<typename H> STest4() requires is_same_v<H, TypeH2> { cout << "ctor(TypeH2)" << endl; }
SVV>  ...
SVV>};

SVV>STest4<float> st5_1<TypeH1>();//warning C4930: 'STest4<float> st5_1(void)': prototyped function not called (was a variable definition intended?)
SVV>STest4<float> st5_2<TypeH2>();//warning C4930: 'STest4<float> st5_1(void)': prototyped function not called (was a variable definition intended?)
SVV>

using TypeH1 = int;
using TypeH2 = char;

template <class T> struct Tag{};

template<typename T>
struct STest4
{
  template<typename H> STest4(Tag<H>) requires std::is_same_v<H, TypeH1> { std::cout << "ctor(TypeH1)" << std::endl; }
  template<typename H> STest4(Tag<H>) requires std::is_same_v<H, TypeH2> { std::cout << "ctor(TypeH2)" << std::endl; }
};

int main(int c_argc, char* c_argv[])
{
    STest4<float> st5_1{Tag<TypeH1>{}};
    STest4<float> st5_2{Tag<TypeH2>{}};
    return 0;
}

SVV>using namespace std;
SVV>using u1 = unsigned char;

SVV>template<typename T>struct TypeH;
SVV>using TypeH1 = TypeH<int>;
SVV>using TypeH2 = TypeH<char>;

SVV>template<typename T>
SVV>struct STest4
SVV>{
SVV>  template<typename H> void foo();// ключевой момент
SVV>  template<> void foo<TypeH1>(){ cout << "TypeH1" << endl; }
SVV>};
SVV>//template<>
SVV>template<typename T> void STest4<T>::foo<TypeH2>(){ cout << "TypeH2" << endl; }//error C2768: 'STest4<T>::foo': illegal use of explicit template arguments

SVV>int Test4()
SVV>{
SVV>  STest4<float> st4;
SVV>  st4.foo<TypeH1>();
SVV>  st4.foo<TypeH2>();
SVV>  return 0;
SVV>}
SVV>

#include <iostream>

using u1 = unsigned char;

template<typename T>struct TypeH;
using TypeH1 = TypeH<int>;
using TypeH2 = TypeH<char>;

template <typename>
struct TypeHolder{};

template<typename T>
struct STest4
{
  template<typename H> void foo() { foo(TypeHolder<H>{}); }// ключевой момент
  void foo(TypeHolder<TypeH1>){ std::cout << "TypeH1" << std::endl; }
  void foo(TypeHolder<TypeH2>){ std::cout << "TypeH2" << std::endl; }
};

int main()
{
  STest4<float> st4;
  st4.foo<TypeH1>();
  st4.foo<TypeH2>();
}

...
V>  template<typename H> STest4(Tag<H>) requires std::is_same_v<H, TypeH1> { std::cout << "ctor(TypeH1)" << std::endl; }
V>  template<typename H> STest4(Tag<H>) requires std::is_same_v<H, TypeH2> { std::cout << "ctor(TypeH2)" << std::endl; }
...
V>

STest4(Tag<TypeH1>) { cout << "ctor(TypeH1)" << endl; }
STest4(Tag<TypeH2>) { cout << "ctor(TypeH2)" << endl; }

template <class T>
struct STest4
{
    template <class X> void foo();
};

// полная
template <> template <> void STest4<int>::foo<int>() {}

// полная
template <> template <> void STest4<int>::foo<char>(){}

// частичная
// template <> template <class X> void STest4<int>::foo<X*>(){}

// частичная
// template <class T> template <> void STest4<T>::foo<int>(){}

Partial template specialization
Allows customizing class and variable (since C++14) templates for a given category of template arguments.

A partial specialization of a template provides an alternative definition of the template that is used instead of the primary definition when the arguments in a specialization match those given in the partial specialization.

An explicit specialization of ... can be declared by a declaration introduced by template<> ...

template <typename T> struct S
{
  template <typename U> struct N {};
  template <> struct N<int> {}; // <- Ошибка
};

template <typename T> struct S
{
  template <typename U> struct N {};
};

template <> template <> struct S<int>::N<double> {}; // <- Так можно

template <typename T> template <> struct S<T>::N<double> {}; // <- А вот так нельзя

the declaration shall not explicitly specialize a class member template if its enclosing class templates are not explicitly specialized as well

template <typename T> struct S
{
  template <typename U> struct N {};
  template <> struct N<int> {}; // <- Ошибка
};

struct A
{
    template <typename> struct Foo;
    
    template <typename T> struct Foo<T*> {}; // OK
    template <> struct Foo<int> {}; // error: explicit specialization in non-namespace scope 'struct A'
};