Generic programming using template

There are situations where same algorithms works for different data type.
Suppose a function that returns the Maximum of two numbers:
- Same algorithm (to find the Max number) works with integer and decimal point numbers (float).
Until now we have to write two separate function:
1. int Max(int, int);
2. float Max(float, float)
Through generic programming we can have just one function to find Max of int, float or any other type of values.
In generic programming, you define algorithms and data structures in terms of types that are not specified upfront but are provided later when the code is instantiated with specific types.
Generic programming is a programming paradigm in C++ that focuses on creating reusable and flexible code by using templates.
- It allows you to write algorithms and data structures that can work with various data types, without having to duplicate the code for each specific type.
So if Max() function is called with int parameter, Max function with int parameter is created.
In C++ generic programming is implemented with "template".

Benefits of generic programming

Code Reusability: Generic programming allows you to write code that can be reused with different data types. Instead of duplicating code for each specific type, you can define algorithms and data structures once using templates. This promotes code reuse and reduces code duplication, leading to more maintainable and efficient codebases.
Flexibility: Generic programming provides flexibility by allowing your code to work with a wide range of data types. By using templates, you can write code that adapts to different types at compile-time. This flexibility is especially valuable when working with user-defined types or when you need to support different data representations.
Efficiency: Generic programming in C++ often results in highly efficient code. By using templates, the compiler can generate specialized code for each specific combination of template arguments. This enables the compiler to optimize the code based on the actual types, potentially leading to better performance compared to runtime polymorphism or type erasure techniques.
Abstraction: Generic programming allows you to abstract away specific implementation details and focus on the underlying algorithm or data structure. By separating the generic code from the specifics of the data types, you can achieve a higher level of abstraction, making the code more readable and easier to understand.

Templates

Templates are used to define generic definition of function or classes.
Templates are not related to specific data types.
Templates make it possible to use one function or class to handle many different data types.
The template concept can be used in two different ways:
1. with functions and
2. with classes

Why template?

If we want to use a single function which can handle different data types then either we can use function overloading or template.
Template over function overloading??
- In function overloading have to repeat our code while making function with same name but with different data type.
- While using template we have to write the function definition once.

For example, normally we were doing this ↓

                    
int Max(int n, int m)
{
    return (n < m) ? n : m; // ternary operator
}

float Max(float n, float m)
{
    return (n < m) ? n : m;
}

Observation:

Same algorithm: body of function is same in each case.
They are completely differnt functions because they handle different types of arguments & return value.
This is time consuming & waste of space.
Using template you need to write such function just once, and it works for many different data type.

Now we will use template ↓

                    
template <class T>
T Max(T n, T m)
{
    return (n > m) ? n : m;
}

Key feature:

Represent the data type used by the function i.e T, it is also called template argument.

What the compiler does?

At compile time:

Compiler do nothing for template function.
It cannot generate code as it don't know data type.
It remember template function for future reference.

Code generation of template function take place when that function is invoked.

                                
int x = 3, y = 9;
r = Max(x, y);

Now compiler know that type is 'int'.

So it generates a specific version of the Max() function for type int.

Programs

                            
#include <iostream>
using namespace std;

template <class Type>
Type Max(Type a, Type b)
{
    return (a > b) ? a : b;
}

int main()
{
    float r;
    r = Max(9, 4);
    cout << "Maximum number is : " << r << endl;
    r = Max(54.89, 98.78);
    cout << "Maximum number is : " << r << endl;

    return 0;
}

output ↓

                    
Maximum number is : 9
Maximum number is : 98.78

                      
#include <iostream>
using namespace std;

template <class Type>
void Print(Type a)
{
    cout << "The value is : " << a << endl;
}

int main()
{
    Print(9);
    Print(9.5);
    Print("Curry Power");
    return 0;
}

Output ↓

                
The value is : 9
The value is : 9.5
The value is : Curry Power

                       
                       
#include <iostream>
using namespace std;
template <class Type>
Type add(Type num1, Type num2)
{
    return num1 + num2;
}
int main()
{
    int a = 10, b = 20;
    float x = 10.2, y = 20.2;
    cout << "Sum of " << a << " and " << b << " is = " << add(a, b) << endl;
    cout << "Sum of " << x << " and " << y << " is = " << add(x, y) << endl;
    return 0;
}

                       
#include <iostream>
using namespace std;
template <class Type>
void swap(Type *num1, Type *num2)
{
    Type temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
int main()
{
    int a = 10, b = 20;
    cout << " a and b before swap : " << a << " " << b << endl;
    swap(&a, &b);
    cout << " a and b after swap : " << a << " " << b << endl;
    return 0;
}

                       
#include <iostream>
using namespace std;
template <class Type>
Type max(Type arr[], int size)
{
    Type max = arr[0];
    for (int i = 1; i < size; i++)
    {
        if (arr[i] > max)
            max = arr[i];
    }
    return max;
}
int main()
{
    int arr[] = {1, 2, 33, 4, 5};
    int size = sizeof(arr) / sizeof(int);
    cout << " max number in integer array is : " << max(arr, size) << endl;
    float arr2[] = {1.1, 2.2, 33.3, 4.4, 5.5};
    size = sizeof(arr2) / sizeof(int);
    cout << " max number in float array is : " << max(arr2, size) << endl;
    return 0;
}

Class Templates in OOP using C++

Class templates are used to define generic definition of classes.
Class templates are generally used for data storage (container) classes.
These classes are not related to specific data types and can work with different data types.
A class template consists of statements which are independent of particular data types.

Class Templates syntax ↓

                
Template <class Type>
Class class_name
{
    // class body
};

Class Templates object Syntax ↓

                
Class_name <template argument> object_name;

                
Test<int> objINT;
Test<float> objFLOAT;

Program ↓

                   
#include <iostream>
using namespace std;
template <class Type>
class Test
{
private:
    Type n;

public:
    void getValue()
    {
        cin >> n;
    }
    void printVal()
    {
        cout << "you entered : " << n << endl;
    }
};
int main()
{
    Test<int> objINT;
    cout << "Enter integer value : ";
    objINT.getValue();
    objINT.printVal();
    
    Test<float> objFLOAT;
    cout << "Enter real value : ";
    objFLOAT.getValue();
    objFLOAT.printVal();

    return 0;
}