C++ instantiaion funzione template con i parametri impliciti

Question

non riesco a capire perché il seguente codice compila bene:

#include <iostream>                 

void bar(int x) {                 
    std::cout << "int " << x << std::endl;            
}                     

void bar(double x) {                 
    std::cout << "double " << x << std::endl;           
}                     

template <typename A, typename B> // Note the order of A and B.            
void foo(B x) {                  
    bar((A)x);                   
}                     

int main() {                   
    int x = 1;                   
    double y = 2;                  

    foo<int>(x);  // Compiles OK.                
    foo<double>(y);  // Compiles OK.            

    return 0;                   
} 

Ma se passo l'ordine di A e B come qui di seguito, allora non si compila:

#include <iostream>                 

void bar(int x) {                 
    std::cout << "int " << x << std::endl;            
}                     

void bar(double x) {                 
    std::cout << "double " << x << std::endl;           
}                     

template <typename B, typename A> // Order of A and B are switched. 
void foo(B x) {                  
    bar((A)x);                   
}                     

int main() {                   
    int x = 1;                   
    double y = 2;                  

    foo<int>(x);  // error: no matching function for call to ‘foo(int&)’ 
    foo<double>(y);  // error: no matching function for call to ‘foo(double&)’                

    return 0;                   
}  

EDIT: spiegazioni ad hoc sono i benvenuti, ma sarebbe meglio se qualcuno può indicare esattamente ciò che le specifiche. dice. Grazie!

Answer 1

Nella prima, il compilatore sa che A è int perché specificamente dite così con foo<int>, e sa che B è anche int a causa del parametro che si passa. Quindi sia A sia B sono noti o deducibili (si potrebbe dire: A è fornito, B è implicito).

Tuttavia, nella seconda, poiché B viene prima e A non compare nell'elenco dei parametri, il compilatore non può dire cosa sia A e ti dà un errore. Stai dicendo esplicitamente cosa è B con foo<int>, e quindi il parametro che passi è anche un B che, alla chiamata, è unche concorda con la tua precedente definizione esplicita di B, ma non viene fatto alcun riferimento a A, implicitamente o esplicitamente, quindi il compilatore deve fermarsi e l'errore.

Non hai davvero bisogno dello standard per questo, è solo buon senso. Cosa diavolo sarebbe A essere nel secondo?

Grazie per avermi fatto questa domanda, perché non mi ero reso conto che potevi specificare esplicitamente alcuni parametri e specificare implicitamente altri nella lista dei parametri prima di questo.