Overload Resolution with Function Templates

When there are both function templates and non-template functions available, the compiler uses a specific set of rules to determine which one to call. Here's how it works:

1. The compiler first tries to find an exact match with a non-template function. If it finds one, it calls that function.
2. If there's no exact match with a non-template function, the compiler then tries to find an exact match with a function template. If it finds one, it calls that function.
3. If there's no exact match with either a non-template function or a function template, the compiler then looks for a non-template function that can be called with implicit conversions.
4. If there's no non-template function that can be called with implicit conversions, the compiler then looks for a function template that can be called with implicit conversions.

Here's an example:

1#include <iostream>
2
3void Print(int x) {
4  std::cout << "Non-template function\n";
5}
6
7template <typename T>
8void Print(T x) {
9  std::cout << "Function template\n";
10}
11
12int main() {
13  Print(10);// calls non-template function
14  Print(10.0);// calls function template
15}

1Non-template function
2Function template

In the first call Print(10), the non-template function Print(int) is an exact match, so it's called.

In the second call Print(10.0), there's no exact match with a non-template function. However, the function template Print(T) can be instantiated with T deduced as double to create an exact match, so that's what's called.