¿Cuál es el significado de la plantilla <> con corchetes angulares vacíos en C++?

Question

template<> 
class A{ 
//some class data 
}; 

He visto este tipo de código muchas veces. ¿Cuál es el uso de template<> en el código anterior? ¿Y cuáles son los casos en los que necesitamos ordenar su uso?

Answer 1

template<> le dice al compilador que sigue una especialización de plantilla, específicamente una especialización completa . Normalmente, class A tendría que ser algo como esto:

template<class T> 
class A{ 
    // general implementation 
}; 

template<> 
class A<int>{ 
    // special implementation for ints 
}; 

Ahora, cada vez que se utiliza A<int>, se utiliza la versión especializada. También puede utilizarlo para especializar funciones:

template<class T> 
void foo(T t){ 
    // general 
} 

template<> 
void foo<int>(int i){ 
    // for ints 
} 

// doesn't actually need the <int> 
// as the specialization can be deduced from the parameter type 
template<> 
void foo(int i){ 
    // also valid 
} 

Normalmente, sin embargo, no se debe especializar las funciones, como simple overloads are generally considered superior:

void foo(int i){ 
    // better 
} 

---

Y ahora, para que sea una exageración, es la siguiente una especialización parcial:

template<class T1, class T2> 
class B{ 
}; 

template<class T1> 
class B<T1, int>{ 
}; 

Wo funciona de la misma manera que una especialización completa, solo que la versión especializada se usa siempre que el segundo parámetro de plantilla sea int (por ejemplo, B<bool,int>, B<YourType,int>, etc.).

Answer 2

No se ve bien. Ahora, es posible que haya lugar por escrito:

template<> 
class A<foo> { 
// some stuff 
}; 

... que sería una especialización plantilla para el tipo foo.

Answer 3

template<> introduce una especialización total de una plantilla. Tu ejemplo en sí mismo no es realmente válido; se necesita un escenario más detallado antes de que sea útil:

template <typename T> 
class A 
{ 
    // body for the general case 
}; 

template <> 
class A<bool> 
{ 
    // body that only applies for T = bool 
}; 

int main() 
{ 
    // ... 
    A<int> ai; // uses the first class definition 
    A<bool> ab; // uses the second class definition 
    // ... 
} 

Parece extraño porque es un caso especial de una función mucho más potente, que se llama "la especialización parcial".