C++ Templates

Templates are the foundation of generic programming, which involves writing code in a way that is independent of any specific type.

Templates are blueprints or formulas for creating generic classes or functions. Library containers, such as iterators and algorithms, are examples of generic programming that utilize templates.

Each container has a single definition, such as vector, and we can define many different types of vectors, like vector<int> or vector<string>.

You can use templates to define functions and classes. Let's see how to use them.

Function Templates

The general form of a template function definition is as follows:

template <typename type> ret-type func-name(parameter list)
{
   // Function body
}

Here, type is a placeholder name for the data type used by the function. This name can be used within the function definition.

Below is an example of a function template that returns the maximum of two numbers:

Example

#include <iostream>
#include <string>

using namespace std;

template &lt;typename T>
inline T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
} 
int main ()
{
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl; 

    double f1 = 13.5; 
    double f2 = 20.7; 
    cout << "Max(f1, f2): " << Max(f1, f2) << endl; 

    string s1 = "Hello"; 
    string s2 = "World"; 
    cout << "Max(s1, s2): " << Max(s1, s2) << endl; 

    return 0;
}

When the above code is compiled and executed, it produces the following result:

Max(i, j): 39
Max(f1, f2): 20.7
Max(s1, s2): World

Class Templates

Just as we define function templates, we can also define class templates. The general form of a generic class declaration is as follows:

template <class type> class class-name {
...
}

Here, type is a placeholder type name that can be specified when the class is instantiated. You can define multiple generic data types using a comma-separated list.

The following example defines a class Stack<> and implements generic methods to push and pop elements:

Example

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>

using namespace std;

template &lt;class T>
class Stack { 
  private: 
    vector<T> elems;     // Elements 

  public: 
    void push(T const&);  // Push element
    void pop();               // Pop element
    T top() const;            // Return top element
    bool empty() const{       // Return true if empty.
        return elems.empty(); 
    } 
}; 

template &lt;class T>
void Stack<T>::push (T const& elem) 
{ 
    // Append copy of passed element
    elems.push_back(elem);    
} 

template &lt;class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // Remove last element
    elems.pop_back();         
} 

template &lt;class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // Return copy of last element 
    return elems.back();      
} 

int main() 
{ 
    try {
        Stack<int>         intStack;  // Stack of ints
        Stack<string> stringStack;    // Stack of strings

        // Manipulate int stack
        intStack.push(7);
        cout << intStack.top() << endl;

        // Manipulate string stack
        stringStack.push("hello");
        cout << stringStack.top() << std::endl;
        stringStack.pop();
        stringStack.pop();
    }
    catch (exception const& ex) {
        cerr << "Exception: " << ex.what() << endl;
        return -1;
    }
}

try {
    Stack<int> intStack;    // Stack of int type
    Stack<string> stringStack;    // Stack of string type

    // Operating on the stack of int type
    intStack.push(7);
    cout << intStack.top() << endl;

    // Operating on the stack of string type
    stringStack.push("hello");
    cout << stringStack.top() << std::endl;
    stringStack.pop();
    stringStack.pop();
}
catch (exception const& ex) {
    cerr << "Exception: " << ex.what() << endl;
    return -1;
}

When the above code is compiled and executed, it produces the following result:

7
hello
Exception: Stack<>::pop(): empty stack