C++ Function Template instantiaion with implicit parameters

Question

I can't figure out why the following code compiles fine:

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

But if I switch the order of A and B as below, then it won't compile:

#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: Ad-hoc explanations are welcome, but would be better if someone can point out exact what the spec. says. Thanks!

The compiler can infer the type of B in your first example from the parameter passed to the foo constructor (of type B). In the second example, no such inference can be made, because the template parameter supplied is B, and so is the constructor parameter. The type of A is nowhere in evidence. — Stabledog, Apr 25 '12 at 20:56

Seth Carnegie · Accepted Answer · 2012-04-25T21:08:05.720

7

In the first one, the compiler knows that A is int because you specifically tell it so with foo<int>, and it knows that B is also int because of the parameter that you pass it. So both A and B are known or can be deduced (you could say: A is supplied, B is implied).

However, in the second one, since B comes first and A doesn't appear in the parameter list, the compiler can't tell what A is and gives you an error. You're explicitly telling it what B is with foo<int>, and then the parameter you pass is also a B which, at the call, is an int which agrees with your previous explicit definition of B, but no mention is made of A, implicitly or explicitly, so the compiler must stop and error.

You don't really need the standard for this, it's just common sense. What on earth would A be in the second one?

Thanks for asking this question though, because I didn't realise you could explicitly specify some parameters and implicitly specify others in the parameter list before this.

edited Apr 25 '12 at 21:08

answered Apr 25 '12 at 20:53

Seth Carnegie

73,875
22
181
249

So, this becomes a question of what the spec. says regarding how `A` and `B` are determined. The compiler could have determined `B` because of the input argument first, then figure out `A` from `foo`. Then, both template parameters are determined even in the second case. – kirakun Apr 25 '12 at 20:56
1

@Kirakun not really. `A` and `B` can only be determined if you specify a type in the `<>`, or all the ones that aren't specified in the `<>` are in the parameter list, so the compiler can deduce the type from the call. In the second one, `A` is neither explicitly specified in the `<>` nor is it in the parameter list, so it can't be known. – Seth Carnegie Apr 25 '12 at 20:58
1

@Kirakun just because you put one in the parameter list doesn't mean that it's skipped when you start putting things between the `<>`. They're still in the order they're in in the list `template`, so `B` is first, and then `A` second, always, regardless of the arguments the function takes. – Seth Carnegie Apr 25 '12 at 20:58

C++ Function Template instantiaion with implicit parameters

1 Answers1