Overload di modelli di funzione

Aggiornamento: novembre 2007

In Visual Studio .NET, il compilatore tratta funzioni la cui firma mappata a una specializzazione esplicita di una funzione del modello (anche se la funzione non è preceduta da template<>) come una specializzazione. Ora, tali funzioni sono trattate da overload non modelli.

Il comportamento in fase si esecuzione potrebbe cambiare nei seguenti casi:

// 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.
}

Per l'esempio precedente, notare che il comportamento identico può essere realizzato creando una specializzazione esplicita anziché quello che deve essere un overload f(int). La specializzazione verrà chiamata in entrambe le versioni di Visual Studio .NET 2003 e Visual Studio .NET di Visual C++.

Vedere anche

Riferimenti

Ultime modifiche al compilatore Visual C++