Surcharge de modèles de fonctions
Mise à jour : novembre 2007
Dans Visual Studio .NET, le compilateur a traité les fonctions dont la signature mappait à une spécialisation explicite d'une fonction de modèle (même si la fonction n'était pas précédée par template<>) en tant que spécialisation. Maintenant, de telles fonctions sont traitées en tant que surcharges de non-modèle.
Le comportement à l'exécution peut changer dans les cas comme :
// bc_overloading_of_function_templates.cpp
#include <stdio.h>
template<class T>
void f(T) // called in Visual Studio .NET 2003
{
printf_s("in void f(T)\n");
}
void f(int) // called in Visual Studio .NET
// for identical behavior for both compiler versions, use
// template<> void
// f<int>(int)
{
printf_s("in void f(int)\n");
}
int main()
{
f<int>(3);
// Visual C++ .NET calls template function specialization
// because explicit template arguments were provided.
// The current compiler will also call specialization because
// explicit template arguments were provided.
// But these will call different functions because the previous
// compiler explicitly specializes on int, and the current
// compiler does not (creates non-template overload)
f(4);
// Visual C++ .NET will call template function specialization
// because no global non-template overload defined.
// The current compiler will call the non-template overload.
}
Pour l'exemple précédent, notez qu'un comportement identique peut être accompli en faisant de f(int) une spécialisation explicite plutôt que ce qui devrait être une surcharge. La spécialisation sera appelée dans les versions Visual Studio .NET 2003 et Visual Studio .NET de Visual C++.