Templates in C++

What are Templates?

• Templates allow you to write code that is type-independent.
• They are useful for creating generic functions and classes.
• They increase code reusability and flexibility.

Types of Templates:

1. Function Templates: For creating generic functions.
2. Class Templates: For creating generic classes.

Why Use Templates?

• Avoids code duplication.
• Allows you to create functions and classes that work with multiple data types.
• Simplifies complex code structures.

Example without Templates:

#include <iostream>
using namespace std;

// Function for integers
int addInt(int a, int b) {
    return a + b;
}

// Function for doubles
double addDouble(double a, double b) {
    return a + b;
}

int main() {
    cout << "Int sum: " << addInt(3, 4) << endl;
    cout << "Double sum: " << addDouble(3.5, 4.2) << endl;
    return 0;
}

Output:

Int sum: 7
Double sum: 7.7

Problem:

• Code duplication (two functions for similar tasks).
• What if we need more types (float, long, etc.)?

Function Templates

Function templates allow you to create a single function that works with any data type.

Syntax:

template <typename T>
T functionName(T param1, T param2) {
    // Function body
}

• template <typename T> - T is a placeholder for any data type.
• You can also use template <class T> (both are the same).

Example:

#include <iostream>
using namespace std;

// Generic function template
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    cout << "Int sum: " << add(3, 4) << endl;
    cout << "Double sum: " << add(3.5, 4.2) << endl;
    cout << "String concatenation: " << add(string("Hello "), string("World")) << endl;
    return 0;
}

Output:

Int sum: 7
Double sum: 7.7
String concatenation: Hello World

Explanation:

• The add function works with any data type (int, double, string).
• The compiler automatically generates the correct version of the function.

Multiple Template Parameters

You can use multiple template parameters.

Example:

#include <iostream>
using namespace std;

template <typename T, typename U>
void display(T a, U b) {
    cout << "First: " << a << ", Second: " << b << endl;
}

int main() {
    display(10, "Apples");
    display(3.14, 42);
    return 0;
}

Output:

First: 10, Second: Apples
First: 3.14, Second: 42

Explanation:

• The display function can take two different data types.
• You can have as many template parameters as needed.

Default Template Arguments

You can set default values for template parameters.

Example:

#include <iostream>
using namespace std;

template <typename T = int>
T multiply(T a, T b) {
    return a * b;
}

int main() {
    cout << "Default (int) multiplication: " << multiply(4, 5) << endl;
    cout << "Double multiplication: " << multiply<double>(4.2, 3.5) << endl;
    return 0;
}

Output:

Default (int) multiplication: 20
Double multiplication: 14.7

Class Templates

Class templates allow you to create classes that work with any data type.

Syntax:

template <typename T>
class ClassName {
    T data;
public:
    ClassName(T value) : data(value) {}
    void display() {
        cout << "Data: " << data << endl;
    }
};

Example:

#include <iostream>
using namespace std;

// Generic class template
template <typename T>
class Container {
    T value;
public:
    Container(T v) : value(v) {}
    void display() {
        cout << "Value: " << value << endl;
    }
};

int main() {
    Container<int> intObj(42);
    Container<double> doubleObj(3.14);
    Container<string> stringObj("Hello");

    intObj.display();
    doubleObj.display();
    stringObj.display();
    return 0;
}

Output:

Value: 42
Value: 3.14
Value: Hello

Template Specialization

• Sometimes, you need a specific implementation for a specific data type.
• Template specialization allows you to define a custom implementation.

Syntax:

template <typename T>
class ClassName {
    // Generic implementation
};

// Specialized version for int
template <>
class ClassName<int> {
    // Specialized implementation for int
};

Example:

#include <iostream>
using namespace std;

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

// Specialized version for strings
template <>
class Printer<string> {
public:
    void print(string value) {
        cout << "String Printer: " << value << endl;
    }
};

int main() {
    Printer<int> intPrinter;
    Printer<string> stringPrinter;

    intPrinter.print(42);
    stringPrinter.print("Hello World");

    return 0;
}

Output:

Generic: 42
String Printer: Hello World

Explanation:

• The generic template works for all data types.
• The specialized template works only for strings.

Non-Type Template Parameters

• You can use constant values as template parameters.
• These are useful for creating containers of a fixed size.

Example:

#include <iostream>
using namespace std;

template <typename T, int size>
class Array {
    T arr[size];
public:
    void set(int index, T value) {
        if (index >= 0 && index < size)
            arr[index] = value;
    }

    T get(int index) const {
        return arr[index];
    }
};

int main() {
    Array<int, 5> intArray;
    intArray.set(0, 10);
    intArray.set(1, 20);

    cout << "Array[0]: " << intArray.get(0) << endl;
    cout << "Array[1]: " << intArray.get(1) << endl;

    return 0;
}

Output:

Array[0]: 10
Array[1]: 20

Best Practices for Templates

1. Use templates for generic code and avoid code duplication.
2. Use template specialization for specific cases.
3. Avoid complex template code unless necessary.
4. Prefer standard template library (STL) for common data structures.

Summary

In this tutorial, you learned:

• What templates are and why they are useful.
• How to create function and class templates.
• How to use template specialization.
• Advanced techniques like non-type template parameters.