c++ - 带有隐式参数的 C++ 函数模板实例化

Question

我不明白为什么下面的代码编译得很好：

#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;                                                                         
}

但是，如果我将Aand的顺序切换B如下，那么它将无法编译：

#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;                                                                         
}      

编辑：欢迎临时解释，但如果有人能指出具体的规范会更好。说。谢谢！

Answer 1

在第一个中，编译器知道这A是int因为您专门用 告诉它foo<int>，并且它知道这B也是int因为您传递给它的参数。所以A和B都是已知的或可以推导出来的（你可以说：A是提供的，B是隐含的）。

但是，在第二个中，由于出现在B第一个并且A没有出现在参数列表中，编译器无法判断是什么A并给你一个错误。您明确地告诉它Bwith 是什么foo<int>，然后您传递的参数也是 a Bwhich，在调用时，int它与您先前的明确定义一致B，但没有隐式或显式地提及A，因此编译器必须停止和错误。

你真的不需要这个标准，这只是常识。第二个到底是A什么？

不过感谢您提出这个问题，因为我没有意识到您可以在此之前显式指定一些参数并在参数列表中隐式指定其他参数。