Open In App

Templates in C++ with Examples

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

A template is a simple yet very powerful tool in C++. The simple idea is to pass the data type as a parameter so that we don’t need to write the same code for different data types. For example, a software company may need to sort() for different data types. Rather than writing and maintaining multiple codes, we can write one sort() and pass the datatype as a parameter. 

C++ adds two new keywords to support templates: ‘template’ and ‘type name’. The second keyword can always be replaced by the keyword ‘class’.

How Do Templates Work?

Templates are expanded at compiler time. This is like macros. The difference is, that the compiler does type-checking before template expansion. The idea is simple, source code contains only function/class, but compiled code may contain multiple copies of the same function/class. 

templates-cpp

Function Templates

We write a generic function that can be used for different data types. Examples of function templates are sort(), max(), min(), printArray(). 

To know more about the topic refer to Generics in C++.

Example:

C++




// C++ Program to demonstrate
// Use of template
#include <iostream>
using namespace std;
 
// One function works for all data types.  This would work
// even for user defined types if operator '>' is overloaded
template <typename T> T myMax(T x, T y)
{
    return (x > y) ? x : y;
}
 
int main()
{
    // Call myMax for int
    cout << myMax<int>(3, 7) << endl;
    // call myMax for double
    cout << myMax<double>(3.0, 7.0) << endl;
    // call myMax for char
    cout << myMax<char>('g', 'e') << endl;
 
    return 0;
}


Output

7
7
g

 Example: Implementing Bubble Sort using templates in C++

C++




// C++ Program to implement
// Bubble sort
// using template function
#include <iostream>
using namespace std;
 
// A template function to implement bubble sort.
// We can use this for any data type that supports
// comparison operator < and swap works for it.
template <class T> void bubbleSort(T a[], int n)
{
    for (int i = 0; i < n - 1; i++)
        for (int j = n - 1; i < j; j--)
            if (a[j] < a[j - 1])
                swap(a[j], a[j - 1]);
}
 
// Driver Code
int main()
{
    int a[5] = { 10, 50, 30, 40, 20 };
    int n = sizeof(a) / sizeof(a[0]);
 
    // calls template function
    bubbleSort<int>(a, n);
 
    cout << " Sorted array : ";
    for (int i = 0; i < n; i++)
        cout << a[i] << " ";
    cout << endl;
 
    return 0;
}


Output

 Sorted array : 10 20 30 40 50 

Class Templates 

Class templates like function templates, class templates are useful when a class defines something that is independent of the data type. Can be useful for classes like LinkedList, BinaryTree, Stack, Queue, Array, etc. 

Example:

C++




// C++ Program to implement
// template Array class
#include <iostream>
using namespace std;
 
template <typename T> class Array {
private:
    T* ptr;
    int size;
 
public:
    Array(T arr[], int s);
    void print();
};
 
template <typename T> Array<T>::Array(T arr[], int s)
{
    ptr = new T[s];
    size = s;
    for (int i = 0; i < size; i++)
        ptr[i] = arr[i];
}
 
template <typename T> void Array<T>::print()
{
    for (int i = 0; i < size; i++)
        cout << " " << *(ptr + i);
    cout << endl;
}
 
int main()
{
    int arr[5] = { 1, 2, 3, 4, 5 };
    Array<int> a(arr, 5);
    a.print();
    return 0;
}


Output

 1 2 3 4 5

Can there be more than one argument for templates? 

Yes, like normal parameters, we can pass more than one data type as arguments to templates. The following example demonstrates the same.

Example:

C++




// C++ Program to implement
// Use of template
#include <iostream>
using namespace std;
 
template <class T, class U> class A {
    T x;
    U y;
 
public:
    A() { cout << "Constructor Called" << endl; }
};
 
int main()
{
    A<char, char> a;
    A<int, double> b;
    return 0;
}


Output

Constructor Called
Constructor Called

Can we specify a default value for template arguments? 

Yes, like normal parameters, we can specify default arguments to templates. The following example demonstrates the same. 

Example:

C++




// C++ Program to implement
// Use of template
#include <iostream>
using namespace std;
 
template <class T, class U = char> class A {
public:
    T x;
    U y;
    A() { cout << "Constructor Called" << endl; }
};
 
int main()
{
    // This will call A<char, char>
    A<char> a;
 
    return 0;
}


Output

Constructor Called

What is the difference between function overloading and templates? 

Both function overloading and templates are examples of polymorphism features of OOP. Function overloading is used when multiple functions do quite similar (not identical) operations, templates are used when multiple functions do identical operations.

What happens when there is a static member in a template class/function? 

Each instance of a template contains its own static variable. See Templates and Static variables for more details.

What is template specialization? 

Template specialization allows us to have different codes for a particular data type. See Template Specialization for more details.

Can we pass non-type parameters to templates? 

We can pass non-type arguments to templates. Non-type parameters are mainly used for specifying max or min values or any other constant value for a particular instance of a template. The important thing to note about non-type parameters is, that they must be const. The compiler must know the value of non-type parameters at compile time. Because the compiler needs to create functions/classes for a specified non-type value at compile time. In the below program, if we replace 10000 or 25 with a variable, we get a compiler error. 

Example:

C++




// C++ program to demonstrate
// working of non-type parameters
// to templates in C++
#include <iostream>
using namespace std;
 
template <class T, int max> int arrMin(T arr[], int n)
{
    int m = max;
    for (int i = 0; i < n; i++)
        if (arr[i] < m)
            m = arr[i];
 
    return m;
}
 
int main()
{
    int arr1[] = { 10, 20, 15, 12 };
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
 
    char arr2[] = { 1, 2, 3 };
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
 
    // Second template parameter
    // to arrMin must be a
    // constant
    cout << arrMin<int, 10000>(arr1, n1) << endl;
    cout << arrMin<char, 256>(arr2, n2);
   
    return 0;
}


Output

10
1

Here is an example of a C++ program to show different data types using a constructor and template. We will perform a few actions 

  • passing character value by creating an object in the main() function.
  • passing integer value by creating an object in the main() function.
  • passing float value by creating an object in the main() function.

Example:

C++




// C++ program to show different data types using a
// constructor and template.
#include <iostream>
using namespace std;
 
// defining a class template
template <class T> class info {
public:
    // constructor of type template
    info(T A)
    {
        cout << "\n"
             << "A = " << A
             << " size of data in bytes:" << sizeof(A);
    }
    // end of info()
}; // end of class
 
// Main Function
int main()
{
    // clrscr();
 
    // passing character value by creating an objects
    info<char> p('x');
 
    // passing integer value by creating an object
    info<int> q(22);
 
    // passing float value by creating an object
    info<float> r(2.25);
 
    return 0;
}


Output

A = x size of data in bytes:1
A = 22 size of data in bytes:4
A = 2.25 size of data in bytes:4

Template Argument Deduction

Template argument deduction automatically deduces the data type of the argument passed to the class or function templates. This allows us to instantiate the template without explicitly specifying the data type.

For example, consider the below function template to multiply two numbers:

template <typename t>
t multiply (t num1,t num2) { return num1*num2; }

In general, when we want to use the multiply() function for integers, we have to call it like this:

multiply<int> (25, 5);

But we can also call it:

multiply(23, 5);

We don’t explicitly specify the type ie 1,3 are integers.

The same is true for the template classes(since C++17 only). Suppose we define the template class as:

template<typename t>
class student{
    private:
       t total_marks;
    public:
       student(t x) : total_marks(x) {}
};

If we want to create an instance of this class, we can use any of the following syntax:

student<int> stu1(23);
    or
student stu2(24);

Note: It is important to note thet the template argument deduction for a classes is only available since C++17, so if we 

Example of Template Argument Deduction

The below example demonstrates how the STL vector class template deduces the data type without being explicitly specified.

C++




// C++ Program to illustrate template arguments deduction in
// STL
#include <iostream>
#include <vector>
 
using namespace std;
 
int main()
{
    // creating a vector<float> object without specifying
    // type
    vector v1{ 1.1, 2.0, 3.9, 4.909 };
    cout << "Elements of v1 : ";
    for (auto i : v1) {
        cout << i << " ";
    }
 
    // creating a vector<int> object without specifying type
    vector v2{ 1, 2, 3, 4 };
    cout << endl << "Elements of v2 : ";
    for (auto i : v2) {
        cout << i << " ";
    }
}


Output

Elements of v1 : 1.1 2 3.9 4.909 
Elements of v2 : 1 2 3 4

Note: The above program will fail compilation in C++14 and below compiler since class template arguments deduction was added in C++17.

Function Template Arguments Deduction

Function template argument deduction has been part of C++ since the C++98 standard. We can skip declaring the type of arguments we want to pass to the function template and the compiler will automatically deduce the type using the arguments we passed in the function call.

Example: In the following example, we demonstrate how functions in C++ automatically deduce their type by themselves.

C++




// C++ program to illustrate the function template argument
// deduction
#include <iostream>
using namespace std;
 
// defining function template
template <typename t> t multiply(t first, t second)
{
    return first * second;
}
 
// driver code
int main()
{
    auto result = multiply(10, 20);
    std::cout << "Multiplication OF 10 and 20: " << result
              << std::endl;
 
    return 0;
}


Output

Multiplication OF 10 and 20: 200


Note: For the function templates which is having the same type for the arguments like template<typename t> void function(t a1, t a2){}, we cannot pass arguments of different types.

Class Template Arguments Deduction (C++17 Onwards)

The class template argument deduction was added in C++17 and has since been part of the language. It allows us to create the class template instances without explicitly definition the types just like function templates.

Example: In the following example, we demonstrate how the compiler automatically class templates in C++.

C++




// C++ Program to implement
// Class Template Arguments
// Deduction
#include <iostream>
#include <string>
#include <typeinfo>
using namespace std;
 
// defining class template
template <typename t>
class student {
private:
    string student_name;
    t total_marks;
 
public:
    student();
    // parameterized constructor
    student(string n, t m)
    {
        student_name = n;
        total_marks = m;
    }
 
    void getinfo()
    {
        cout << "STUDENT NAME: " << student_name << endl;
        cout << "TOTAL MARKS: " << total_marks << endl;
        cout << "Type ID: " << typeid(total_marks).name()
             << endl;
    }
};
 
int main()
{
    // student <int> is used to fulfill
      // template requirements
    student<int> s1("vipul", 100);
    student<int> s2("yash", 100.0);
 
    s1.getinfo();
    s2.getinfo();
 
    return 0;
}


Output

STUDENT NAME: vipul
TOTAL MARKS: 100
Type ID: i
STUDENT NAME: yash
TOTAL MARKS: 100
Type ID: d

Here, i means int, and d means double.

For template metaprogramming, refer to the following article – Template Metaprogramming.

Take a Quiz on Templates. Java also supports these features. Java calls it generics.



Last Updated : 12 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads