Perché questa funzione modello non si comporta come previsto?

Stavo leggendo le funzioni del modello e mi sono confuso con questo problema:

#include <iostream>

void f(int) {
    std::cout << "f(int)\n";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << "  ";
    f(val);
}

void f(double) {
    std::cout << "f(double)\n";
}

template void g<double>(double);

int main() {
    f(1.0); // f(double)
    f(1);   // f(int)
    g(1.0); // d  f(int), this is surprising
    g(1);   // i  f(int)
}

I risultati sono gli stessi se non scrivo template void g<double>(double);.

Penso che g<double>dovrebbe essere istanziato dopo f(double), e quindi la chiamata a fin gdovrebbe chiamare f(double). Sorprendentemente, si chiama ancora f(int)in g<double>. Qualcuno può aiutarmi a capire questo?

Dopo aver letto le risposte, ho capito qual è la mia confusione.

Ecco un esempio aggiornato. È per lo più invariato tranne per il fatto che ho aggiunto una specializzazione per g<double>:

#include <iostream>

void f(int){cout << "f(int)" << endl;}

template<typename T>
void g(T val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

void f(double){cout << "f(double)" << endl;}

//Now use user specialization to replace
//template void g<double>(double);

template<>
void g<double>(double val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

int main() {
    f(1.0); // f(double)
    f(1);  // f(int)
    g(1.0); // now d  f(double)
    g(1);  // i  f(int)
}

Con la specializzazione dell'utente, g(1.0)si comporta come mi aspettavo.

Il compilatore non dovrebbe fare automaticamente questa stessa istanza g<double>nello stesso posto (o anche dopo main(), come descritto nella sezione 26.3.3 di The C ++ Programming Language , 4th edition)?

Il nome fè un nome dipendente (dipende Tdall'argomento val) e verrà risolto in due passaggi :

1. La ricerca non ADL esamina le dichiarazioni di funzione ... che sono visibili dal contesto di definizione del modello .
2. ADL esamina le dichiarazioni di funzione ... che sono visibili dal contesto di definizione del modello o dal contesto di istanza del modello .

void f(double)non è visibile dal contesto di definizione del modello e ADL non lo troverà, perché

Per argomenti di tipo fondamentale, l'insieme associato di spazi dei nomi e classi è vuoto

Possiamo leggermente modificare il tuo esempio:

struct Int {};
struct Double : Int {};

void f(Int) { 
    std::cout << "f(Int)";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << ' ';
    f(val);
    // (f)(val);
}

void f(Double) { 
    std::cout << "f(Double)";
}

int main() {
    g(Double{});
}

Ora ADL troverà void f(Double)nel secondo passaggio e l'output sarà 6Double f(Double). Possiamo disabilitare ADL scrivendo (f)(val)(o ::f(val)) invece di f(val). Quindi l'output sarà 6Double f(Int), in accordo con il tuo esempio.

Il problema f(double)non è stato dichiarato nel punto in cui lo si chiama; se sposti la sua dichiarazione davanti a template g, verrà chiamata.

Modifica: Perché si dovrebbe usare l'istanza manuale?

(Parlerò solo di modelli di funzione, argomentazioni analoghe valgono anche per i modelli di classe.) L'uso principale è ridurre i tempi di compilazione e / o nascondere il codice del modello agli utenti.

I programmi C ++ sono integrati in file binari in 2 passaggi: compilazione e collegamento. Perché la compilazione di una chiamata di funzione abbia esito positivo, è necessaria solo l'intestazione della funzione. Perché il collegamento abbia esito positivo, è necessario un file oggetto contenente il corpo compilato della funzione.

Ora, quando il compilatore vede una chiamata di una funzione basata su modelli , cosa fa dipende dal fatto che conosca il corpo del modello o solo l'intestazione. Se vede solo l'intestazione fa la stessa cosa che se la funzione non fosse stata modificata: inserisce le informazioni sulla chiamata per il linker nel file oggetto. Ma se vede anche il corpo del modello fa anche un'altra cosa: crea un'istanza corretta del corpo, compila questo corpo e lo inserisce anche nel file oggetto.

Se più file di origine chiamano la stessa istanza della funzione modello, ciascuno dei loro file oggetto conterrà una versione compilata dell'istanza della funzione. (Linker lo sa e risolve tutte le chiamate in una singola funzione compilata, quindi ce ne sarà solo una nell'ultimo binario del programma / libreria.) Tuttavia, al fine di compilare ciascuno dei file sorgente, la funzione ha dovuto essere istanziata e compilato, che ha richiesto tempo.

È sufficiente che il linker faccia il suo lavoro se il corpo della funzione si trova in un file oggetto. Creare un'istanza manuale del modello in un file di origine è un modo per fare in modo che il compilatore inserisca il corpo della funzione nel file oggetto del file di origine in questione. (È un po 'come se la funzione fosse chiamata, ma l'istanza è scritta in un posto in cui la chiamata di funzione non sarebbe valida.) Al termine, tutti i file che chiamano la tua funzione possono essere compilati conoscendo solo l'intestazione della funzione, quindi risparmiando tempo ci vorrebbe per istanziare e compilare il corpo della funzione con ciascuna delle chiamate.

La seconda ragione (nascondere l'implementazione) potrebbe avere senso ora. Se l'autore di una biblioteca desidera che gli utenti della sua funzione modello possano utilizzare la funzione, di solito fornisce loro il codice del modello, in modo che possano compilarlo da soli. Se voleva mantenere segreto il codice sorgente del modello, potrebbe creare un'istanza manuale del modello nel codice che utilizza per creare la libreria e fornire agli utenti la versione dell'oggetto così ottenuta invece del sorgente.

Questo ha senso?