Understanding Templates in C++ | C++ Programming Tutorial

Welcome to C++ Programming Tutorial

Your guide to understanding Templates in C++.

Understanding the Basics of Templates in C++

Templates in C++ allow you to write generic and reusable code that can work with any data type. There are two primary types of templates: function templates and class templates. Below, I'll explain each with full examples and explanations.

1. Function Templates

A function template is a blueprint for creating a function that can operate with any data type. Instead of writing multiple functions for different data types, you can write a single function template.

Example: A Function Template to Swap Two Values


#include <iostream>

// Define the template
template <typename T>
void swapValues(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    double a = 1.1, b = 2.2;

    // Swap integers
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swapValues(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    // Swap doubles
    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
    swapValues(a, b);
    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}

Explanation:

This single function can handle swapping for any data type, making it reusable and type-independent.

2. Class Templates

A class template allows you to create a class that can work with any data type. This is particularly useful for creating data structures like linked lists, stacks, or pairs that can operate on various types.

Example: A Class Template for a Pair of Values


#include <iostream>

// Define the class template
template <typename T>
class Pair {
private:
    T first, second;
public:
    // Constructor
    Pair(T a, T b) : first(a), second(b) {}

    // Methods to get the values
    T getFirst() { return first; }
    T getSecond() { return second; }

    // Method to display the pair
    void display() {
        std::cout << "Pair: (" << first << ", " << second << ")" << std::endl;
    }
};

int main() {
    // Create a pair of integers
    Pair<int> intPair(1, 2);
    intPair.display();

    // Create a pair of doubles
    Pair<double> doublePair(1.1, 2.2);
    doublePair.display();

    // Create a pair of strings
    Pair<std::string> stringPair("Hello", "World");
    stringPair.display();

    return 0;
}

Explanation:

This class template is highly versatile, allowing the creation of pairs for any data type.

3. Member Function Templates

Member function templates allow you to define template functions inside a non-template or template class. These functions can then operate on data types specified at runtime, making the class more flexible.

Example: A Class with a Member Function Template

#include <iostream>
#include <string>

class Example {
public:
    template <typename T>
    void display(T value) {
        std::cout << "Value: " << value << std::endl;
    }

    void normalDisplay(int value) {
        std::cout << "Normal Display Value: " << value << std::endl;
    }
};

int main() {
    Example ex;
    ex.display(100);       // Calls display<int>(int)
    ex.display(20.5);      // Calls display<double>(double)
    ex.display("Hello");   // Calls display<const char*>(const char*)
    ex.normalDisplay(50);  // Calls normalDisplay(int)

    return 0;
}

The display function template inside the Example class allows displaying values of any type. The normalDisplay function is not a template and is specific to integers. When display is called, the compiler deduces the type of T from the argument and generates a specific version of the function.

4. Template Specialization

Template specialization allows you to define a specific implementation of a template for a particular data type. This is useful when the general implementation is not suitable for a specific type.

Example: Specializing a Function Template for char*

#include <iostream>
#include <cstring>

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

// Specialization for const char*
template <>
const char* findMax<const char*>(const char* a, const char* b) {
    return (strcmp(a, b) > 0) ? a : b;
}

int main() {
    int x = 10, y = 20;
    const char* str1 = "Apple";
    const char* str2 = "Orange";

    std::cout << "Max of x and y: " << findMax(x, y) << std::endl;          // Uses general template
    std::cout << "Max of str1 and str2: " << findMax(str1, str2) << std::endl; // Uses specialized template

    return 0;
}

The general findMax template works for most types like integers, doubles, etc. The specialized template for const char* compares C-style strings using strcmp because direct comparison using > wouldn’t work correctly for strings. The specialized template is selected automatically by the compiler when the argument types match.

5. Non-Type Template Parameters

Non-type template parameters allow you to pass constant values (like integers, pointers, or references) to templates. These parameters must be known at compile time.

Example: A Class Template with a Non-Type Parameter

#include <iostream>

template <int size>
class Array {
private:
    int arr[size]; // Array of fixed size
public:
    void fill(int value) {
        for (int i = 0; i < size; i++) {
            arr[i] = value;
        }
    }
    void print() const {
        for (int i = 0; i < size; i++) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    Array<5> array; // Creates an array of size 5
    array.fill(10); // Fill array with the value 10
    array.print();  // Prints: 10 10 10 10 10

    Array<3> smallArray; // Creates an array of size 3
    smallArray.fill(7);  // Fill array with the value 7
    smallArray.print();  // Prints: 7 7 7

    return 0;
}

The Array class template has a non-type parameter size, which specifies the size of the array. The size parameter must be a constant expression known at compile time. Different instances of the Array template can be created with different sizes, making the template versatile.

6. Variadic Templates

Variadic templates allow you to create templates that can accept a variable number of arguments. This is useful when you don’t know the exact number of arguments your function or class will handle.

Example: A Variadic Function Template

#include <iostream>

// Base case for recursion: single argument
template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}

// Recursive case: more than one argument
template <typename T, typename... Args>
void print(T first, Args... args) {
    std::cout << first << " ";
    print(args...); // Recursively calls print for the rest of the arguments
}

int main() {
    print(1, 2.5, "Hello", 'A'); // Outputs: 1 2.5 Hello A

    print("Variadic", "templates", "are", "powerful"); // Outputs: Variadic templates are powerful

    return 0;
}

The print function template uses recursion to handle a variable number of arguments. The base case handles the situation when only one argument is left, printing it. The recursive case handles more than one argument by printing the first and then recursively calling itself for the remaining arguments. Variadic templates can be used with classes, but function templates are a common use case.

Previous Next
Modern Footer