Overloading function templates (C++ only)
You may overload a function template either by a non-template function or by another function template.
If you call the name of an overloaded function template, the compiler
will try to deduce its template arguments and check its explicitly
declared template arguments. If successful, it will instantiate a
function template specialization, then add this specialization to
the set of candidate functions used in overload
resolution. The compiler proceeds with overload resolution, choosing
the most appropriate function from the set of candidate functions.
Non-template functions take precedence over template functions. The
following example describes this:
#include <iostream>
using namespace std;
template<class T> void f(T x, T y) { cout << "Template" << endl; }
void f(int w, int z) { cout << "Non-template" << endl; }
int main() {
f( 1 , 2 );
f('a', 'b');
f( 1 , 'b');
}
The following is the output of the above example:
Non-template
Template
Non-template
The function call f(1, 2)
could match
the argument types of both the template function and the non-template
function. The non-template function is called because a non-template
function takes precedence in overload resolution.The function call f('a', 'b')
can only match the argument
types of the template function. The template function is called.
Argument deduction fails for the function call f(1, 'b')
;
the compiler does not generate any template function specialization
and overload resolution does not take place. The non-template function
resolves this function call after using the standard conversion from char
to int
for
the function argument 'b'
.