Специализация шаблонного класа

template <int Size>
class MyClass
{
public:
  int Method1();
  int Method2();
};
 
template <>
class MyClass<0>
{
public:
  /* хотелось бы не писать еще раз реализацию, так как она меняться не должна. */
  int Method1();
  /* Новая реализация. */
  int Method2();
};

template<class T>
struct Compare
{
     bool operator () (T first, T second)
     {
         return first < second;
     } 
};
 
template<>
struct Compare<char*>
{
    bool operator () (char* first, char* second)
    {
       return strcmp(first, second) < 0;
    }
};

template<int Size>
class BaseClass
{
protected:
   int Method1();
   int Method2();
};
 
template<int Size>
class FirstClass:public BaseClass<Size>
{
public:
  int Method1();
  int Method2(); 
};
 
template<>
class SecondClass<0>:public BaseClass<0>
{
public:
   int Method2();
};

template<>
class SecondClass<0>:public BaseClass<0>
{
public:
   int Method2();
};

class SecondClass :public BaseClass<0>
{
public:
   int Method2();
};

#include <stdio.h>
 
template <class T>
class C
{
  public:
    void M1 (void) { printf ("template M1\n"); }
    void M2 (void) { printf ("template M2\n"); }
};
 
template <>
void C<int>::M2 (void)
{
  printf ("specialized M2\n");
}
 
int
main (void)
{
  C<char> c1;
  C<int> c2;
 
  c1.M1();
  c1.M2();
 
  c2.M1();
  c2.M2();
 
  return 0;
}

template<int Size>
class Class
{
private:
    int arr[Size];
};
 
template<>
class Class<0>
{
private:
   int Int;
};

#include <iostream>
 
class BaseMethods
{
public:
    //Методы из паблика нужны везде кроме каких-то конкретных классов.
    void Method1()
    {
        std::cout<<"Base::Method1\n";
    }
    void Method2()
    {
        std::cout<<"Base::Method2\n";
    }
protected:
    //Нужны везде.
    void Method3()
    {
        std::cout<<"Base::Method3\n";
    }
    BaseMethods() 
    {
    }
};
 
template<int s>
class Some:public BaseMethods
{
public:
    void Method1()
    {
        std::cout<<"Some::Method1\n";
    }
    void Method3()
    {
        BaseMethods::Method3();
    }
};
 
template<>
class Some<0>:protected BaseMethods
{
public:
    void Method3()
    {
        BaseMethods::Method3();
    }
};
 
int main()
{
    //BaseMethods Ob;//ошибка компиляции
    Some<5> SOb;
    SOb.Method1();
    SOb.Method2();
    SOb.Method3();
    Some<0> ZeroSOb;
    //Следующие два метода вызовут ошибку компиляция
    //ZeroSOb.Method1();
    //ZeroSOb.Method2();
    ZeroSOb.Method3();
}