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

但如果我按以下方式切换A和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也是{{1}因为你传递它的参数。因此，int和A都已知或可以推断出来（您可以说：B 提供，A 暗示< / em>的）。

但是，在第二个问题中，由于B排在第一位且B没有出现在参数列表中，编译器无法告诉A是什么并给你一个错误。您明确告诉A B与foo<int>有什么关系，然后您传递的参数也是B，在通话时，它是int同意您先前对B的明确定义，但没有提及A，隐式或显式，因此编译器必须停止并出错。

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

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

具有隐式参数的C ++函数模板实例

1 个答案: