Introduction to Templates

Templates in C++ allow you to define functions and classes with placeholders for types or values. These placeholders are replaced with actual types or values when the template is instantiated. This feature enables generic programming, where the same code can work with different data types.

Key Concepts

• Generic Programming: Writing code that works with any data type.
• Type Parameter: A placeholder for a data type used in templates.
• Template Instantiation: Creating a concrete instance of a template with specific types.

Function Templates

Function templates allow you to define a single function that can work with different data types. Instead of writing multiple functions with similar logic for different types, you use a template to handle various types generically.

Basic Syntax

template <typename T>
T functionName(T parameter) {
    // Function body
}

Example: Function Template for Maximum Value

Here's a function template to find the maximum of two values:

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

Using the Template:

int main() {
    std::cout << "Max of 10 and 20: " << max(10, 20) << std::endl;        // Works with int
    std::cout << "Max of 5.5 and 3.3: " << max(5.5, 3.3) << std::endl;   // Works with double
    std::cout << "Max of 'A' and 'B': " << max('A', 'B') << std::endl;    // Works with char

    return 0;
}

Template Parameter Types

In addition to typename, you can use class to specify a template parameter. Both typename and class are interchangeable in this context.

template <class T>
T min(T a, T b) {
    return (a < b) ? a : b;
}

Class Templates

Class templates enable you to define a class that works with any data type. This is particularly useful for creating data structures and algorithms that can handle different types.

Basic Syntax

template <typename T>
class ClassName {
    T data;
public:
    ClassName(T d) : data(d) {}
    T getData() { return data; }
};

Example: Class Template for a Simple Container

Here’s an example of a class template for a container that holds a value:

template <typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}

    void setValue(T v) {
        value = v;
    }

    T getValue() const {
        return value;
    }
};

Using the Class Template:

int main() {
    Box<int> intBox(123);
    std::cout << "Integer Box: " << intBox.getValue() << std::endl;

    Box<std::string> strBox("Hello, World!");
    std::cout << "String Box: " << strBox.getValue() << std::endl;

    return 0;
}

Template Specialization

Template specialization allows you to define a specific implementation of a template for a particular type. This is useful when you need to handle certain types differently from others.

Full Specialization

Full specialization is when you provide a complete definition for a specific type.

Example:

template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// Specialization for char*
template <>
class Printer<char*> {
public:
    void print(char* value) {
        std::cout << "String: " << value << std::endl;
    }
};

Using the Specialization:

int main() {
    Printer<int> intPrinter;
    intPrinter.print(123);

    Printer<char*> strPrinter;
    char message[] = "Hello, Specialized World!";
    strPrinter.print(message);

    return 0;
}

Partial Specialization

Partial specialization allows you to specialize a template for a subset of types.

Example:

template <typename T, typename U>
class Pair {
    T first;
    U second;
public:
    Pair(T f, U s) : first(f), second(s) {}

    void print() {
        std::cout << first << " - " << second << std::endl;
    }
};

// Partial specialization for when both types are the same
template <typename T>
class Pair<T, T> {
    T value1;
    T value2;
public:
    Pair(T v1, T v2) : value1(v1), value2(v2) {}

    void print() {
        std::cout << value1 << " and " << value2 << " are of the same type" << std::endl;
    }
};

Using Partial Specialization:

int main() {
    Pair<int, double> p1(1, 2.5);
    p1.print();

    Pair<int, int> p2(10, 20);
    p2.print();

    return 0;
}

Use Cases and Examples

Templates are widely used in C++ standard libraries and for creating generic data structures and algorithms. Here are some practical examples and use cases:

Example 1: Implementing a Generic Stack

A stack is a common data structure, and you can implement it as a class template to work with any data type.

template <typename T>
class Stack {
private:
    std::vector<T> elements;
public:
    void push(const T& element) {
        elements.push_back(element);
    }

    T pop() {
        if (elements.empty()) throw std::out_of_range("Stack<>::pop(): empty stack");
        T elem = elements.back();
        elements.pop_back();
        return elem;
    }

    bool isEmpty() const {
        return elements.empty();
    }
};

Using the Stack Template:

int main() {
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    std::cout << "Popped: " << intStack.pop() << std::endl;

    Stack<std::string> strStack;
    strStack.push("Hello");
    strStack.push("World");
    std::cout << "Popped: " << strStack.pop() << std::endl;

    return 0;
}

Example 2: Generic Sorting Function

Templates can be used to create a generic sorting function that works with any type that supports comparison.

template <typename T>
void sortArray(T arr[], int size) {
    for (int i = 0; i < size - 1; ++i) {
        for (int j = i + 1; j < size; ++j) {
            if (arr[i] > arr[j]) {
                T temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

Using the Sorting Function:

int main() {
    int intArr[] = {5, 3, 8, 1, 2};
    int n = sizeof(intArr) / sizeof(intArr[0]);
    sortArray(intArr, n);
    std::cout << "Sorted integers: ";
    for (int i : intArr) std::cout << i << " ";
    std::cout << std::endl;

    double doubleArr[] = {3.1, 2.4, 5.6, 1.7};
    int m = sizeof(doubleArr) / sizeof(doubleArr[0]);
    sortArray(doubleArr, m);
    std::cout << "Sorted doubles: ";
    for (double d : doubleArr) std::cout << d << " ";
    std::cout << std::endl;

    return 0;
}

Example 3: Generic Linked List

A linked list is another data structure that can be implemented as a template to handle any type.

template <typename T>
class Node {
public:
    T data;
    Node* next;
    Node(T d) : data(d), next(nullptr) {}
};

template <typename T>
class LinkedList {
private:
    Node<T>* head;
public:
    LinkedList() : head(nullptr) {}

    void append(T value) {
        Node<T>* newNode = new Node<T>(value);
        if (!head) {
            head = newNode;
        } else {
            Node<T>* temp = head;
            while (temp->next) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }

    void print() {
        Node<T>* temp = head;
        while (temp) {
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << std::endl;
    }

    ~LinkedList() {
        Node<T>* temp = head;
        while (temp) {
            Node<T>* next = temp->next;
            delete temp;
            temp = next;
        }
    }
};

Using the Linked List Template:

int main() {
    LinkedList<int> intList;
    intList.append(10);
    intList.append(20);
    intList.append(30);
    intList.print();

    LinkedList<std::string> strList;
    strList.append("Alice");
    strList.append("Bob");
    strList.append("Charlie");
    strList.print();

    return 0;
}

Conclusion

Templates are a cornerstone of generic programming in C++, enabling you to write flexible and reusable code. By understanding function templates, class templates, and template specialization, you can create powerful and versatile code that works with different data types. The examples provided illustrate how templates can be used in practical scenarios, such as implementing data structures and algorithms. Mastering templates will greatly enhance your ability to write efficient and maintainable C++ code.