When to Use Function Templates vs Class Templates in C++? A Practical Guide

Function Templates

Definition

A function template defines a generic function that can operate on arguments of any type. The compiler generates a concrete function for each type used at call‑site, enabling a single implementation to work with integers, floating‑point numbers, strings, or user‑defined types.

Example

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T getMax(T a, T b) {
    cout << "Comparing two values..." << endl;
    return (a > b) ? a : b;
}

int main() {
    int i1 = 10, i2 = 20;
    cout << "Max int: " << getMax(i1, i2) << endl;

    double d1 = 88.5, d2 = 92.3;
    cout << "Max double: " << getMax(d1, d2) << endl;

    string s1 = "Alice", s2 = "Bob";
    cout << "Max string: " << getMax(s1, s2) << endl;
    return 0;
}

Typical Use Cases

Utility functions : simple operations such as swap, compare, or sort.

Algorithmic helpers : generic search, calculation, or transformation routines.

Conversion utilities : type‑casting or formatting helpers.

Class Templates

Definition

A class template defines a generic class that can store and manipulate data of any type. It is useful when the class needs to maintain state (e.g., containers, managers) and provide multiple member functions that operate on that state.

Example

#include <iostream>
#include <vector>
#include <string>
using namespace std;

template <typename T>
class SmartBox {
private:
    vector<T> items;
    string boxName;
public:
    SmartBox(const string& name) : boxName(name) {
        cout << "Box " << boxName << " ready." << endl;
    }
    void addItem(const T& item) {
        items.push_back(item);
        cout << "Added item to " << boxName << endl;
    }
    void showItems() const {
        cout << "Contents of " << boxName << ":" << endl;
        for (size_t i = 0; i < items.size(); ++i) {
            cout << "  " << i+1 << ". " << items[i] << endl;
        }
        cout << "Total: " << items.size() << " items" << endl;
    }
    size_t getCount() const { return items.size(); }
};

int main() {
    SmartBox<int> intBox("Integers");
    intBox.addItem(100);
    intBox.addItem(200);
    intBox.showItems();

    SmartBox<string> strBox("Strings");
    strBox.addItem("template");
    strBox.addItem("class");
    strBox.showItems();

    SmartBox<double> dblBox("Doubles");
    dblBox.addItem(3.14);
    dblBox.addItem(2.71);
    dblBox.showItems();
    return 0;
}

Typical Use Cases

Data containers : arrays, linked lists, stacks, queues.

Management systems : student records, product inventories, resource pools.

Complex objects : any type that requires multiple related operations and internal state.

Decision Guide

Simple, stateless operations → function template.

Need to store state or provide many related operations → class template.

Unclear requirements → start with a function template and refactor to a class template if needed.

Advanced Techniques

Template Specialization

template <typename T>
void printInfo(const T& data) {
    cout << "Data: " << data << endl;
}

// Specialization for std::string
template <>
void printInfo<string>(const string& data) {
    cout << "String: \"" << data << "\"" << endl;
}

Default Template Parameters

template <typename T, int Size = 10>
class FixedArray {
    T data[Size];
    // ... additional members ...
};

FixedArray<int> a1;          // Size defaults to 10
FixedArray<double, 20> a2;    // Size explicitly set to 20