Argumento de plantilla predeterminado y especialización parcial

Explíqueme por qué el siguiente código cumple y funciona perfectamente. Estoy muy confundido.

#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;
}

¿No debería caer en la forma generalizada de la clase de plantilla Base?

El argumento predeterminado se aplica a la especialización y, de hecho, una especialización debe aceptar (por así decirlo) los argumentos predeterminados de la plantilla base. Intentando especificar un valor predeterminado en la especialización:

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

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

… es un error.

Asimismo, si cambiamos la especialización para que su especialización sea para un tipo otro que el predeterminado proporcionado por la plantilla base:

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

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

…entonces se elegirá la plantilla base.

Entonces, lo que sucede es esto: primero se eligen los tipos para los argumentos de la plantilla. En este caso (sin tipo especificado en la instanciación), ambos tipos se basan en los argumentos de plantilla predeterminados especificados en la plantilla base.

Luego (como un paso básicamente separado) lleva a cabo un análogo de resolución de sobrecarga en todas las plantillas que se ajustan a esos tipos de argumentos. Como es habitual para la resolución de sobrecarga, se prefiere un tipo que se especifica explícitamente sobre uno que se especifica implícitamente, por lo que su especialización (que especificó int explícitamente) se prefiere a la plantilla base (que especificó int implícitamente).

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

Aquí los valores/inicialización por defecto para A y B han sido declarados respectivamente como int y double.

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

Aquí, en las definiciones de clase, el primer argumento es algo así como un valor constante (aquí int; ¿por qué declarar de esta manera solo complicando las cosas? Es mejor eliminar el primer argumento de la plantilla) y el segundo argumento de la plantilla es B, cuyo valor predeterminado es ‘doble’.

Base<> base;

Cuando creas el objeto de la clase. Aunque no especifica los argumentos de la plantilla, el compilador toma los valores predeterminados de los argumentos (A y B) que son ‘int’ y ‘double’ y el código se ejecuta sin errores ni advertencias.

Vea lo que sucede cuando crea el objeto como:
Base<float,char> b; o Base<char,char> b;

Cuando escribes Base<> base; el compilador intentará averiguar si la instanciación de Base<> la clase es posible o no, si es posible, el código funcionaría bien. En este caso es posible debido al argumento de plantilla predeterminado de Base porque el compilador sabe si escribes Base<> necesita crear un objeto de Base<int,double>. es decir: debido a:

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

Así que el código funciona bien.