Specializing function template for reference types

ali_bahoo picture ali_bahoo · Jan 13, 2011 · Viewed 7.2k times · Source

Why is the output of this code :

#include <iostream>  
template<typename T> void f(T param) 
{ 
   std::cout << "General" << std::endl ; 
} 
template<> void f(int& param) 
{ 
   std::cout << "int&" << std::endl ; 
}  

int main() 
{   
  float x ;  f (x) ;   
  int y ; f (y) ;   
  int& z = y ; f (z) ; 
}  

is

General
General
General

The third one is surprizing because the function was specialized exactly for int&

Edit : I know that overloading might be a proper solution. I just want to learn the logic behind it.

Answer

Johannes Schaub - litb picture Johannes Schaub - litb · Jan 13, 2011

The type of both the expression y and the expression z is int. A reference appearing in an expression won't keep reference type. Instead, the type of the expression will be the referenced type, with the expression being an lvalue.

So in both cases, T is deduced to int, and thus the explicit specialization is not used at all.

What's important to note (other than that you should really use overloading, as another guy said), is that you have a non-reference function parameter in your template. Before any deduction of T against the argument type is done, the argument type will be converted from arrays to a pointer to their first element (for functions, arguments will be converted to function pointers). So a function template with a non-reference function parameter doesn't allow for accurate deduction anyway.