C++ Templates (Class and Function) with Examples

In C++, templates are a powerful feature that allows you to write generic code that can work with any data type. They provide a mechanism for defining generic functions and generic classes that can operate on any data type without being explicitly rewritten for each type. Templates enhance code reusability, reduce redundancy, and make your programs more flexible and extensible.

In this blog post, we will cover the basics of C++ templates, specifically function templates and class templates, with examples to help you understand how to use them effectively.

What Are Templates in C++?

Templates allow you to define functions and classes that can work with any data type. Instead of writing separate code for each data type (e.g., int, float, double), you write a single, generic definition that can be used for any type. C++ has two main types of templates:

1. Function Templates
2. Class Templates

1. Function Templates in C++

A function template allows you to define a function that works with any data type. The type is specified at the time the function is called, not when it is written. This is useful when the same function logic can be applied to different types of data.

Syntax of Function Templates

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

• template <typename T>: Declares the function template with T as the placeholder for any data type.
• T functionName(T parameter): The function uses T as the type for the parameter and return value.

Example: Function Template to Find Maximum Value

Here’s a simple example of a function template that finds the maximum of two values:

#include <iostream>
using namespace std;

// Function template to find the maximum of two values
template <typename T>
T findMax(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // Using the function template with int
    cout << "Max of 10 and 20: " << findMax(10, 20) << endl;
    
    // Using the function template with double
    cout << "Max of 10.5 and 20.5: " << findMax(10.5, 20.5) << endl;

    // Using the function template with string
    cout << "Max of Apple and Orange: " << findMax(string("Apple"), string("Orange")) << endl;

    return 0;
}

Output:

Max of 10 and 20: 20
Max of 10.5 and 20.5: 20.5
Max of Apple and Orange: Orange

Explanation:

1. We define a function template findMax that works with any data type T.
2. The function compares two values of type T and returns the larger one.
3. In main(), we use the template function with different data types (int, double, and string). The compiler automatically deduces the type of T based on the arguments provided.

2. Class Templates in C++

A class template allows you to define a class that can work with any data type. You can create an instance of the class with any type when you need it, making it more flexible and reusable.

Syntax of Class Templates

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

• template <typename T>: Declares the class template with T as the placeholder for any data type.
• T data: The data member of the class is of type T.
• ClassName(T data): The constructor accepts a value of type T.

Example: Class Template for a Generic Box

Let’s define a simple class template for a Box that can hold any type of data.

#include <iostream>
using namespace std;

// Class template for a Box
template <typename T>
class Box {
    T value;
public:
    Box(T value) : value(value) {}
    T getValue() { return value; }
};

int main() {
    // Creating a Box for int
    Box<int> intBox(100);
    cout << "Box holds integer: " << intBox.getValue() << endl;

    // Creating a Box for double
    Box<double> doubleBox(45.67);
    cout << "Box holds double: " << doubleBox.getValue() << endl;

    // Creating a Box for string
    Box<string> stringBox("Hello, C++ Templates!");
    cout << "Box holds string: " << stringBox.getValue() << endl;

    return 0;
}

Output:

Box holds integer: 100
Box holds double: 45.67
Box holds string: Hello, C++ Templates!

Explanation:

1. We define a class template Box that holds a value of type T.
2. The constructor initializes the value of type T, and the getValue() method returns that value.
3. In main(), we create instances of Box with different data types (int, double, and string).

Template Specialization

While templates are useful for generic programming, sometimes you may want to define a specific implementation for a particular data type. This is where template specialization comes in. Template specialization allows you to define a different implementation for a specific type.

Example: Template Specialization for a Specific Data Type

Let’s modify the Box class to handle a special case when the type is string:

#include <iostream>
using namespace std;

// General template for Box
template <typename T>
class Box {
    T value;
public:
    Box(T value) : value(value) {}
    T getValue() { return value; }
};

// Specialization of Box for string
template <>
class Box<string> {
    string value;
public:
    Box(string value) : value(value) {}
    string getValue() { 
        return "Box holds a string: " + value; 
    }
};

int main() {
    Box<int> intBox(100);
    Box<string> stringBox("Hello, Template Specialization!");

    cout << intBox.getValue() << endl;
    cout << stringBox.getValue() << endl;

    return 0;
}

Output:

100
Box holds a string: Hello, Template Specialization!

Explanation:

1. The general Box template works for all types.
2. We define a template specialization for the string type, which returns a different message when getValue() is called.
3. In the main() function, the Box<string> instance returns the specialized message.

Conclusion

C++ templates are a powerful tool for writing generic, reusable code. Function templates allow you to write functions that can work with any data type, while class templates enable you to create flexible classes that can handle different data types dynamically.

By using templates, you can avoid redundancy, reduce boilerplate code, and improve the maintainability of your programs. Additionally, template specialization lets you provide custom behavior for specific types when necessary.

As you gain experience with templates, you’ll find them to be an essential feature for writing efficient and flexible C++ code. Happy coding!