Default template parameter partial specialization

Please explain to me why the following piece of code complies and works perfectly. I am very confused.

#include<iostream>
template<class A = int, class B=double>
class Base
{};

template<class B>
class Base <int, B>
{
public:
  Base()
  {
     std::cout<<"it works!!!!!\n";
  }
};

int main()
{
  Base<> base; // it prints "it works!!!!!"
  return 0;
}

Shouldn't it fall into the generalized form of the template class Base?

The default argument applies to the specialization -- and, in fact, a specialization must accept (so to speak) the base template's default argument(s). Attempting to specify a default in the specialization:

template<class A = int, class B=double>
class Base
{};

template<class B=char>
// ...

...is an error.

Likewise, if we change the specialization so that its specialization is for a type other than the default provided by the base template:

template<class A = int, class B=double>
class Base
{};

template<class B>
class Base <char, B>

...then the base template will be chosen.

So, what's happening is this: first the types for the template arguments are chosen. In this case (no type specified at instantiation), both types are based on the default template arguments specified in the base template.

Then (as a basically separate step) it carries out an analog of overload resolution on all templates that fit those argument types. As usual for overload resolution, a type that's specified explicitly is preferred over one that's specified implicitly, so your specialization (which specified int explicitly) is preferred over the base template (which specified int implicitly).

When you write Base<> base; the compiler will try to find out if instantiation of Base<> class is possible or not if it is possible the code would work fine. In this case it is possible due to the default template argument of Base because the compiler knows if you if you write Base<> it needs to create a object of Base<int,double>. i.e: because of:

template<class A = int, class B=double>
class Base
{};

So the code works fine.

template<class A = int, class B=double>
class Base
{};

Here the default values/initialization for A and B have been declared respectively as int and double.

 template<class B>
 class Base <int, B>

Here in class definitions, the first argument is something like a constant value(here int; why declare this way just making things complex? Better remove the first template argument) and the second template argument is B who default value is 'double'.

Base<> base;

When you create the object of the class. Although you do not specify the template arguments, the compiler takes default values of the arguments(A and B)which are 'int' and 'double' and the code executes without any errors or warnings.
See what happens when you create the object as:
Base<float,char> b; or Base<char,char> b;