Overloading Function Template

Programming Language & Its Applications — Generic Programming and Exception Handling, NEC licence examination syllabus (Nepal Engineering Council).

Overloading Function Templates

Templates and ordinary functions competing for the same call — and the precise rules that decide the winner.

🌍 Where this lives: the standard library is built on this. std::swap is a template, but std::vector supplies its own overload that swaps three internal pointers instead of copying every element — turning an O(n) operation into O(1). std::max has a general template plus an initializer_list overload. Every time you write a fast path for one specific type while keeping a generic fallback, you are using this mechanism. Search "std::swap specialization vs overload"; the answer explains why library authors prefer overloading to specialisation, which is a genuinely subtle distinction that trips up experienced programmers.

Three ways to have several candidates

1. OVERLOADED TEMPLATES — different parameter lists template <typename T> T sum(T a, T b); template <typename T> T sum(T a, T b, T c); template <typename T> T sum(const T arr[], int n); 2. A NON-TEMPLATE ("ordinary") FUNCTION alongside a template template <typename T> void print(T v); void print(const char *s); /* exact-match wins */ 3. TEMPLATE SPECIALISATION — a custom body for one type template <typename T> void print(T v) { ... } template <> void print<const char*>(const char *s) { ... } ^^^ note the empty <> — this is a SPECIALISATION of the template, not a new overload THE RESOLUTION ORDER — the compiler tries, in this order: 1. an EXACT-MATCH non-template function 2. the MOST SPECIALISED matching template 3. a non-template function requiring CONVERSIONS 4. a template requiring conversions (only trivial ones — templates do NOT get user-defined conversions during deduction) Rule of thumb: a non-template wins ties. A more specialised template beats a more general one. And if nothing matches exactly, the ordinary function's conversions are considered before the template's.

resolution.cpp

#include <iostream>
#include <string>

/* 1. the general template */
template <typename T>
void show(T v) {
    std::cout << "  [template]      " << v << "\n";
}

/* 2. a MORE SPECIALISED template — takes a pointer */
template <typename T>
void show(T *p) {
    std::cout << "  [template T*]   " << *p << "\n";
}

/* 3. an ordinary non-template function */
void show(int v) {
    std::cout << "  [non-template]  " << v << "\n";
}

/* 4. an explicit specialisation for double */
template <>
void show<double>(double v) {
    std::cout << "  [specialised]   " << v << " (double)\n";
}

int main() {
    int    i = 42;
    double d = 3.14;
    char   c = 'x';
    std::string s = "hello";

    show(i);        /* non-template: EXACT match       */
    show(d);        /* specialised template for double */
    show(c);        /* template T=char (non-template
                       would need char->int conversion)  */
    show(s);        /* template T=std::string          */
    show(&i);       /* the T* overload is MORE
                       specialised than T                */

    /* force the template even though a non-template
       exact match exists */
    show<int>(i);   /* explicit: template T=int        */

    /* a conversion the template will NOT do */
    show(7L);       /* long: template T=long wins over
                       long->int conversion             */
    return 0;
}
Output:
  [non-template]  42
  [specialised]   3.14 (double)
  [template]      x
  [template]      hello
  [template T*]   42
  [template]      42
  [template]      7

Walk through each decision — this is exactly the trace an exam question asks for. show(i) int · non-template show(int): EXACT match, rank 1 · template T=int: also exact, but rank 2 → NON-TEMPLATE wins. A non-template beats a template when both match equally well. show(d) double · non-template show(int): needs double→int (lossy) · template: T=double, exact — and there is an explicit specialisation for double → SPECIALISED template wins. show(c) char · non-template show(int): char→int is a PROMOTION · template T=char: EXACT → TEMPLATE wins. An exact template match beats a non-template needing a conversion. show(s) std::string · non-template show(int): no conversion exists → TEMPLATE, the only candidate. show(&i) int* · show(T) with T=int*: matches · show(T*) with T=int: ALSO matches, and is MORE SPECIALISED (it accepts fewer types) → show(T*) wins by partial ordering. show<int>(i) explicit → deduction is skipped; the TEMPLATE is used even though the non-template was a better match. This is how you deliberately bypass an overload. show(7L) long · non-template show(int): needs long→int, a lossy standard conversion · template T=long: EXACT match → TEMPLATE wins, printing "[template] 7". Confirmed by compiling: on this platform sizeof(long) is 8 and sizeof(int) is 4, so they are distinct types and the template's exact match beats the conversion — the same reasoning as the char case. SUMMARY OF THE RANKING, as demonstrated: exact non-template > exact template exact template > non-template + conversion more specialised template > more general template explicit <T> bypasses deduction entirely

The char and long cases together give the cleanest statement of the rule: a non-template wins only when it matches as well as the template. The moment it needs any conversion — a promotion for char, a narrowing for long — the template's exact match takes it. So adding void show(int) to a codebase changes behaviour for int arguments only, never for anything that merely converts to int.

Specialisation versus overloading

These look similar and behave differently: /* OVERLOAD — a separate function, participates fully in overload resolution */ template <typename T> void f(T v); void f(int v); /* non-template */ template <typename T> void f(T *p); /* another template */ /* SPECIALISATION — NOT a separate function. It supplies a custom BODY for one instantiation of an existing template. It does NOT participate in overload resolution. */ template <typename T> void f(T v); template <> void f<int>(int v); WHY THE DIFFERENCE MATTERS: Specialisation happens AFTER overload resolution picks a template. So: template <typename T> void g(T); /* #1 */ template <typename T> void g(T*); /* #2 */ template <> void g<int*>(int*); /* specialises #1! */ int *p; g(p); → resolution picks #2 (more specialised template), so the specialisation of #1 is NEVER USED. That is the famous trap. The specialisation looks like it should handle int*, but resolution chose a different template first. THE PRACTICAL GUIDANCE, and it is what the standard library follows: · for FUNCTIONS, prefer OVERLOADING to specialisation · reserve full specialisation for CLASS templates, where it works predictably and is genuinely useful Also note: only FULL specialisation is allowed for function templates. PARTIAL specialisation (fixing some parameters, leaving others) works only for CLASS templates.

spec_vs_overload.cpp

#include <iostream>
#include <cstring>

/* ---- the generic version ---- */
template <typename T>
bool isEqual(T a, T b) {
    std::cout << "    (generic) ";
    return a == b;
}

/* ---- SPECIALISATION for const char*: compare CONTENT,
        not pointer addresses ---- */
template <>
bool isEqual<const char*>(const char *a, const char *b) {
    std::cout << "    (specialised for const char*) ";
    return std::strcmp(a, b) == 0;
}

/* ---- an OVERLOAD taking two different types ---- */
template <typename T, typename U>
bool isEqual(T a, U b) {
    std::cout << "    (two-type overload) ";
    return a == b;
}

int main() {
    std::cout << std::boolalpha;

    std::cout << "  isEqual(5, 5)          = ";
    std::cout << isEqual(5, 5) << "\n";

    std::cout << "  isEqual(2.5, 2.5)      = ";
    std::cout << isEqual(2.5, 2.5) << "\n";

    /* WITHOUT the specialisation this compares ADDRESSES
       and would print false for equal text */
    const char *s1 = "hello";
    char buf[10]; std::strcpy(buf, "hello");
    const char *s2 = buf;
    std::cout << "  isEqual(\"hello\", buf) = ";
    std::cout << isEqual(s1, s2) << "\n";

    std::cout << "  isEqual(5, 5.0)        = ";
    std::cout << isEqual(5, 5.0) << "\n";
    return 0;
}
Output:
  isEqual(5, 5)          =     (generic) true
  isEqual(2.5, 2.5)      =     (generic) true
  isEqual("hello", buf) =     (specialised for const char*) true
  isEqual(5, 5.0)        =     (two-type overload) true

The const char* case is the reason specialisation exists here. With only the generic template: isEqual(s1, s2) where s1 and s2 point at DIFFERENT memory holding the SAME text → a == b compares POINTERS → false The specialisation uses strcmp and correctly returns true. This is a real, classic bug. It is also why std::string exists: with std::string, operator== compares content and no specialisation is needed. The lesson generalises — when a generic algorithm is WRONG for one type rather than merely slow, that type needs its own version. Compare with the performance motivation: std::swap<T> generic: 3 copies, O(n) for a vector vector::swap special: 3 pointer swaps, O(1) Here the generic version is CORRECT but slow, and the specialised one is an optimisation.

Worked example — a printing library with progressive specialisation

printer.cpp

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>

/* level 1: the catch-all template */
template <typename T>
void describe(const T &v) {
    std::cout << "  generic      : " << v << "\n";
}

/* level 2: overload for pointers — dereference and mark */
template <typename T>
void describe(T *p) {
    if (!p) { std::cout << "  pointer      : nullptr\n"; return; }
    std::cout << "  pointer to   : " << *p << "\n";
}

/* level 3: overload for a vector — iterate */
template <typename T>
void describe(const std::vector<T> &v) {
    std::cout << "  vector[" << v.size() << "]   : ";
    for (const T &x : v) std::cout << x << " ";
    std::cout << "\n";
}

/* level 4: non-template exact matches for the types that
   need special treatment */
void describe(bool b) {
    std::cout << "  bool         : " << (b ? "true" : "false") << "\n";
}
void describe(char c) {
    std::cout << "  char         : '" << c << "' (ASCII "
              << int(c) << ")\n";
}
void describe(double d) {
    std::cout << "  double       : " << std::fixed
              << std::setprecision(4) << d
              << std::defaultfloat << "\n";
}

int main() {
    int         i  = 42;
    double      d  = 3.14159265;
    char        c  = 'A';
    bool        b  = true;
    std::string s  = "Nepal";
    std::vector<int> v{10, 20, 30};
    int        *p  = &i;
    int        *np = nullptr;

    describe(i);
    describe(d);
    describe(c);
    describe(b);
    describe(s);
    describe(v);
    describe(p);
    describe(np);
    return 0;
}
Output:
  generic      : 42
  double       : 3.1416
  char         : 'A' (ASCII 65)
  bool         : true
  generic      : Nepal
  vector[3]   : 10 20 30
  pointer to   : 42
  pointer      : nullptr

Each line proves a different resolution rule: i (int) → no non-template for int, no better template → GENERIC d (double) → non-template describe(double) is an EXACT match → beats the template c (char) → non-template describe(char), exact → wins, and prints the ASCII value 65 for 'A' ✔ b (bool) → non-template, exact → prints "true" instead of the 1 the generic << would give s (string) → only the generic matches v (vector) → the vector<T> overload is more specialised than the plain T overload → wins p (int*) → the T* overload is more specialised → wins np (nullptr) → same overload, null-checked Notice WHY bool and char needed non-template overloads: the generic version would print `1` for true and `A` for 'A' with no ASCII value. The generic template is not wrong, just uninformative — and an overload fixes it for exactly one type without touching the others. That layered structure — a generic fallback plus targeted overloads — is how real libraries are built. Each overload handles one type better, and anything unanticipated still works through the generic path.

🌍 Go further: the layered-overload technique above becomes far cleaner with C++17's if constexpr, which lets one function branch on the type at compile time instead of needing separate overloads: if constexpr (std::is_pointer_v<T>) { ... } else { ... }, with the untaken branch never even compiled. C++20 concepts go further still, letting you order overloads by constraint. Before either existed, library authors used a technique called SFINAE (std::enable_if) which worked but produced famously unreadable code. Search "if constexpr vs SFINAE vs concepts" to see the same problem solved three times across twenty years — it is a good short history of modern C++.

💡 Exam angle: state the resolution order — exact-match non-template first, then the most specialised template, then conversions. Be ready to trace which version a set of calls picks; that is the standard question. Know the specialisation syntax template <> void f<int>(int) with its empty angle brackets, and the key distinction: a specialisation supplies a body for an existing template and does not take part in overload resolution, whereas an overload does. Mention that function templates allow only full, never partial, specialisation.

Syllabus points

Overloaded function templates

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.