Templates in C++

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.

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

Go read about STL in this article.