La deduzione del modello sembra errata

Question

Il modello dedotto sembrava sbagliato, perché (c) è chiamato piuttosto che (b)?

#include <iostream> 
using namespace std; 
template<class T> void f(T){cout << "f(T)";}//(a) 
template<> void f<>(int*){cout << "f(int*)";}//(b) 
template<class T> void f(T*){cout << "f(T*)";}//(c) 
//void f(int*){cout <<"POD:f(int*)";}//(d) 

int main(int argc,char*argv[]) 
{ 
    int p = 1; 
    f(&p); 
    cout <<endl; 
    return 0; 
} 

uscita:

f(T*)

Answer 1

Ok, cerchiamo di impostare direttamente ciò che abbiamo prima.

(a) è un modello di funzione. (b) è una specializzazione di quel modello di funzione. (c) è un altro modello di funzione che sovraccarica (a).

Quando si scrive f(&p) ci sono due sovraccarichi da considerare: i due modelli di funzione, (a) e (c). In (c) T* è più specializzato di T in (a), quindi (c) viene selezionato.

Consideriamo ora il commento (d). Questa non è una specializzazione del modello di funzione (a), ma un sovraccarico aggiuntivo. Per risolvere la chiamata f(&p), è necessario considerare tre sovraccarichi. (d) non è un modello e ha int* corrispondente al tipo di &p, quindi viene selezionato rispetto agli altri due.

Answer 2

La specializzazione del modello deve venire dopo il modello. Qui, nel tuo caso, sembra che questo:

template<class T> void f(T){cout << "f(T)";}//(a) // Template 1 
template<> void f<>(int*){cout << "f(int*)";}//(b) // Specialization of template 1 
template<class T> void f(T*){cout << "f(T*)";}//(c) // Template 2, conceals template 1 

Quindi, si ottiene modello 2 un'istanza. toi modo corretto fanno è:

template<class T> void f(T*){cout << "f(T*)";} // Template 1 
template<class T> void f(T){cout << "f(T)";} // Template 2 
template<> void f<>(int*){cout << "f(int*)";} // Specialization of the template 1 

uscita:

f(int*)