Überladen von Funktionsvorlagen
Aktualisiert: November 2007
In Visual Studio .NET behandelte der Compiler Funktionen, deren Signatur einer expliziten Spezialisierung einer Vorlagenfunktion zugeordnet war (auch wenn der Funktion nicht template<> vorangestellt war), als Spezialisierung. Jetzt werden solche Funktionen als nicht auf Vorlagen basierende Überladungen behandelt.
Das Laufzeitverhalten ändert sich möglicherweise in Fällen wie den folgenden:
// 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.
}
Beachten Sie im vorherigen Beispiel, dass ein identisches Verhalten erzielt werden kann, indem f(int) zu einer expliziten Spezialisierung anstatt zu dem gemacht wird, was eine Überladung sein sollte. Die Spezialisierung wird sowohl in der Visual Studio .NET 2003-Version als auch in der Visual Studio .NET-Version von Visual C++ aufgerufen.