Aqui está um exemplo simples:
#include <iostream>
template <class T>
void print(T in){
printf("NOT printing int\n");
}
template <> // <-- template specialization
void print<int>(int in){
printf("printing int\n");
}
int main(){
print(5); // printing int
return 0;
}
Mas a int
versão pode ser escrita mesmo sem usar modelos, como este:
void print(int in){
printf("printing int\n");
}
Então, qual é o ponto de especialização de modelo aqui?
#include <iostream>
template <class T>
void print(){
printf("printing float\n");
}
template <>
void print<int>(){
printf("printing int\n");
}
int main(){
print<float>();
return 0;
}
A questão é que você não pode fazer tudo com sobrecargas. Considere, por exemplo, um caso em que não há argumento:
template<class T>
void foo();
Não há como sobrecarregar essa função porque não há argumentos. Mas pode ser chamado com instanciação explícita:
foo<int>();
E essas instanciações podem ser especializadas.
Depois, há especializações de modelo de classe que, obviamente, não podem ser feitas usando sobrecarga de função.
Há alguma sobreposição entre o que pode ser feito com sobrecargas e o que pode ser feito com a especialização de modelo. Normalmente é considerado melhor usar uma sobrecarga quando for uma opção.
Este artigo é coletado da Internet.
Se houver alguma infração, entre em [email protected] Delete.
deixe-me dizer algumas palavras