Templates in C++
Tags: cpp
Published: 2021-07-03 13:48:08

# Templates in C++ Language

The keyword `template` is used to define function templates and class templates in our C++ program.
It introduces generic programming, which makes a way for programmers to write more efficient code.

So, now there are two ways in which we can use template, 


- 
 ### Function template

     Function template is also known as ***generic function***.

`syntax` creating function template:
```
template<class type> 
type func_name(type arg1, type arg2, ....){
     ...
};
// here type is a placeholder for generalisation of data type.
```
It creates a function template named `func_name` with any number of arguments.

**Let's learn this with an example**,

Program to find the smaller number from the given two numbers* without the use of `template`*:
```
#include<iostream>

using namespace std;

// without the use of template keyword.
int small(int a, int b){
    if(a > b){
        return(b);    
    }else{
        return(a);
    }
};

double small(double a, double b){ // function overloading
    if(a > b){
        return(b);
    }else{
        return(a);
    }
};


int main(){
    cout<<small(2,6)<<endl;
    cout<<small(2.4,1.9);
    return 0;
}

/*
OUTPUT
2
1.9
*/
```
(32 Lines of Code)

To avoid using different data types in a function,  *Use `template`*.

```
#include<iostream>

using namespace std;

// Program using template keyword
template<class X>
X small(X a, X b){ // here X is a generic data type, making 'small' a generic function.
    if(a < b){
        return(b);
    }else{
        return(a);
    }
};

int main(){
    cout<<small(3,4)<<endl;
    cout<<small(3.4,1.6); // no function overloading reduces the lines of code in a program
    return 0;
}

/*
OUTPUT
3
1.6
*/

```
(25 Lines of Code)

Example 2:
```
template<class X, class Y>  
X big(X a, Y b){        //different data types
    if(a > b){
        return a;
    }else{
        return b;
    }
};

int main(){
    cout<<big(4,3.4)<<endl;
    cout<<big(1.99,-5);
    return 0;
}

/*
OUTPUT:
4
1.99
*/

```

(20 Lines of Code)

- 
 ### Class template

     Class template is also known as ***generic class***.

```
template<class type> 
class class_name{
    ...
};
// here type is also a placeholder to generalise a class.
```
It creates a class template named `class_name`.

**Let's also learn this with an example, 
Here we are making a `arrayList` class without the use of template.**
```
#include<iostream>

using namespace std;

class arrayList{
    private:
        struct controlBlock{
            int capacity;
            int *arr_ptr;
        };

    controlBlock *s;

    public:
        arrayList(int capacity){ // constructor of arrayList class
            s = new controlBlock;
            s -> capacity = capacity;
            s -> arr_ptr = new int[s->capacity];
        }
        void addElement(int index, int data){ // method to add elements to the list
            if(index >= 0 && index <= s->capacity - 1){
                s -> arr_ptr[index]  = data;
            }else{
                cout<<"Array index not valid";
            }
        }
        void viewElement(int index, int &data){
            if(index >=0 && index <= s->capacity - 1){
                data = s->arr_ptr[index];
            }else{
                cout<<"Array index not valid";
            }
        }
        void viewList(){ // method to view the list
            int i;
            for(i = 0; i < s->capacity; i++){
                cout<<" "<<s->arr_ptr[i];
            }
        }
};

int main(){
    int data;
    arrayList list1(4);
    list1.addElement(0,2);
    list1.addElement(1,12);
    list1.addElement(2,22);
    // list1.addElement(3,32); if not assigned, by default 0 is assigned.
    // list1.viewElement(0,data);
    // cout<<data;
    list1.viewList();
    return 0;
}

/*
OUTPUT:
2
12
22
0
*/
```
(61 Lines of Code)

*Image explanation of code.*

![template_c++.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1613036200174/AEfvN3Sbj.png)

Now, templating our above program will result in increased possibilities of input with the same number of lines of code.

visit : [arrayList_with_template.cpp](https://github.com/abhishekchandra2522k/CPPrograms/blob/master/Standard%20Template%20Library%20/arrayList_with_template.cpp)

Go read about STL in [this article](https://dev.to/abhishekchandra2522k/standard-template-library-in-c-2h10).