Sobrecarga de modelos de função
No Visual Studio. NET, o compilador tratados funções cuja assinatura mapeado para uma especialização explícita de uma função do modelo (mesmo que a função não era precedida por template<>) sistema autônomo uma especialização. Agora, funções, são tratadas sistema autônomo modelo não sobrecargas.
Comportamento em time de execução podem ser alterados em casos assim:
// 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.
}
No exemplo anterior, observe que pode ser obtido comportamento idêntico, tornando f(int) uma especialização explícita em vez do que deve ser uma sobrecarga. A especialização será chamada nas versões do Visual Studio .NET 2003 e o Visual Studio .NET do Visual C++.