When the compiler processes a function template, it does not generate executable code immediately. Instead, it acts as a blueprint. Specific function definitions are only generated when the template is instantiated with concrete types. This process involves two distinct compilation phases:

1. Template Definition Check: The compiler checks the template code itself for syntax errors, ignoring the specific types.
2. Instantiation Check: After type substitution, the compiler checks the generated code to ensure operations are valid for the substituted types.

Consider type conversion rules during instantiation. When types are automatically deduced, the compiler enforces strict type matching and does not perform implicit conversions. However, if types are explicitly specified, implicit type conversion is permitted.

#include <iostream>

using namespace std;

template <typename T>
T getMaximum(T x, T y) {
    return (x > y) ? x : y;
}

int main() {
    int val1 = 10;
    int val2 = 20;

    // Automatic deduction: T is int
    cout << "Result: " << getMaximum(val1, val2) << endl;

    // Error: Strict matching required. 'a' is char, val2 is int.
    // cout << getMaximum('a', val2) << endl; 

    // Explicit specification: T is char. Implicit conversion of int to char occurs.
    cout << "Result: " << getMaximum<char>('a', val2) << endl;

    return 0;
}

Verifying Template Instantiation

Since the compiler generates distinct functions for different types, each instantiation has a unique memory address. We can verify this by assigning template instances to function pointers of specific types.

Furthermore, compilation errors within the template logic only surface if that specific instantiation is actually used. If a generated function calls an inaccessible method (like a private copy constructor), the second phase of compilation fails.

#include <iostream>
#include <string>

using namespace std;

class Entity {
    Entity(const Entity&) {} // Private copy constructor
public:
    Entity() {}
};

template <typename T>
void swapValues(T& a, T& b) {
    T temp = a; // Requires accessible copy constructor
    a = b;
    b = temp;
}

// Define function pointer types
using IntFunc = void(*)(int&, int&);
using DoubleFunc = void(*)(double&, double&);
using EntityFunc = void(*)(Entity&, Entity&);

int main() {
    // Compiler deduces T as int and generates specific code
    IntFunc ptrInt = swapValues;

    // Compiler deduces T as double and generates separate code
    DoubleFunc ptrDouble = swapValues;

    // Verify that different instantiations result in different function addresses
    cout << "Int function address:    " << reinterpret_cast<void*>(ptrInt) << endl;
    cout << "Double function address: " << reinterpret_cast<void*>(ptrDouble) << endl;

    // This would cause a compilation error:
    // EntityFunc ptrEntity = swapValues; 
    // The instantiation attempts to call the private copy constructor.
    
    return 0;
}

Multi-Parameter Templates

Function templates can accept multiple type parameters. There are important rules regarding deduction:

1. The return type cannot be automatically deduced from the arguments. It must typically be specified explicitly or placed as the first parameter in the template list to allow partial specification.
2. Type parameters can be partially specified from left to right.

#include <iostream>

using namespace std;

// Return type (R) is the first parameter, followed by argument types
template <typename R, typename T1, typename T2>
R calculateSum(T1 a, T2 b) {
    return static_cast<R>(a + b);
}

int main() {
    // R=int (explicit), T1 and T2 deduced from arguments
    // Result: 4 (precision lost)
    cout << "Sum: " << calculateSum<int>(2.5, 1.5) << endl; 

    // R=float (explicit), T1 and T2 deduced
    // Result: 4.0
    cout << "Sum: " << calculateSum<float>(2.5, 1.5) << endl;

    // R=double, T1=int (explicit), T2 deduced
    // Result: 3.5
    cout << "Sum: " << calculateSum<double, int>(2.5, 1) << endl;

    return 0;
}

Overloading Function Templates

Function templates can coexist with non-template functions (ordinary functions). The compiler follows a specific set of rules to resolve which function to call:

1. Priority to Ordinary Functions: If a non-template function matches perfectly or with standard conversions, it is preferred.
2. Specialization Preference: If a template can generate a function that matches exactly (a "better" match than converting types for an ordinray function), the template is chosen.
3. Forcing Template Usage: An empty template argument list (<>) forces the compiler to use the template mechenism.

#include <iostream>

using namespace std;

template <typename T>
T findMax(T a, T b) {
    cout << "[Template Version] ";
    return (a > b) ? a : b;
}

int findMax(int a, int b) {
    cout << "[Ordinary Function Version] ";
    return (a > b) ? a : b;
}

int main() {
    int m = 10;
    int n = 20;

    // 1. Calls ordinary function (priority)
    cout << findMax(m, n) << endl; 

    // 2. Forces template instantiation
    cout << findMax<>(m, n) << endl; 

    // 3. Calls template (better match for double than converting to int)
    cout << findMax(3.14, 2.71) << endl; 

    // 4. Calls ordinary function (char 'a' converts to int)
    // Template would require strict match or explicit type, which isn't provided.
    cout << findMax('a', 10) << endl; 

    return 0;
}

The output demonstrates the overload resolution logic:

[Ordinary Function Version] 20
[Template Version] 20
[Template Version] 3.14
[Ordinary Function Version] 97