C++ Class Templates

In this tutorial, we will learn about class templates in C++ with the help of examples.
Templates are powerful features of C++ which allows us to write generic programs. There are
two ways we can implement templates:
• Function Templates
• Class Templates
Similar to function templates, we can use class templates to create a single class to work with
different data types.
Class templates come in handy as they can make our code shorter and more manageable.

Class Template Declaration

A class template starts with the keyword template followed by template parameter(s)
inside <> which is followed by the class declaration.

template <class T>

class className {
private:
T var;
... .. ...
public:
T functionName(T arg);
... .. ...
};

In the above declaration, T is the template argument which is a placeholder for the data type
used, and class is a keyword.
Inside the class body, a member variable var and a member function functionName() are both of
type T .

Creating a Class Template Object

Once we've declared and defined a class template, we can create its objects in other classes or
functions (such as the main() function) with the following syntax

className<dataType> classObject;

For example,

className<int> classObject;
className<float> classObject;
className<string> classObject;
Example 1: C++ Class Templates
// C++ program to demonstrate the use of class templates

#include <iostream>
using namespace std;

// Class template
template <class T>
class Number {
private:
// Variable of type T
T num;

public:
Number(T n) : num(n) {} // constructor

T getNum() {
return num;
}
};

int main() {

// create object with int type

Number<int> numberInt(7);

// create object with double type

Number<double> numberDouble(7.7);

cout << "int Number = " << numberInt.getNum() << endl;

cout << "double Number = " << numberDouble.getNum() << endl;

return 0;
}
Output

int Number = 7
double Number = 7.7

In this program. we have created a class template Number with the code

template <class T>

class Number {
private:
T num;

public:
Number(T n) : num(n) {}
T getNum() { return num; }
};

Notice that the variable num , the constructor argument n , and the function getNum() are of
type T , or have a return type T . That means that they can be of any type.
In main() , we have implemented the class template by creating its objects
Number<int> numberInt(7);
Number<double> numberDouble(7.7);

Notice the codes Number<int> and Number<double> in the code above.

This creates a class definition each for int and float , which are then used accordingly.
It is compulsory to specify the type when declaring objects of class templates. Otherwise, the
compiler will produce an error.

//Error
Number numberInt(7);
Number numberDouble(7.7);

Defining a Class Member Outside the Class Template

Suppose we need to define a function outside of the class template. We can do this with the
following code:

template <class T>

class ClassName {
... .. ...
// Function prototype
returnType functionName();
};

// Function definition
template <class T>
returnType ClassName<T>::functionName() {
// code
}

Notice that the code template <class T> is repeated while defining the function outside of the
class. This is necessary and is part of the syntax.
If we look at the code in Example 1, we have a function getNum() that is defined inside the
class template Number .

We can define getNum() outside of Number with the following code:

template <class T>

class Number {
... .. ...
// Function prototype
T getnum();
};

// Function definition
template <class T>
T Number<T>::getNum() {
return num;
}
Example 2: Simple Calculator Using Class Templates
This program uses a class template to perform addition, subtraction, multiplication and
division of two variables num1 and num2 .

The variables can be of any type, though we have only used int and float types in this example.
#include <iostream>
using namespace std;

template <class T>

class Calculator {
private:
T num1, num2;

public:
Calculator(T n1, T n2) {
num1 = n1;
num2 = n2;
}

void displayResult() {
cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
cout << num1 << " + " << num2 << " = " << add() << endl;
cout << num1 << " - " << num2 << " = " << subtract() << endl;
cout << num1 << " * " << num2 << " = " << multiply() << endl;
cout << num1 << " / " << num2 << " = " << divide() << endl;
}

T add() { return num1 + num2; }

T subtract() { return num1 - num2; }
T multiply() { return num1 * num2; }
T divide() { return num1 / num2; }
};

int main() {
Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2);

cout << "Int results:" << endl;

intCalc.displayResult();

cout << endl

<< "Float results:" << endl;
floatCalc.displayResult();

return 0;
}
Output

Int results:
Numbers: 2 and 1.
2+1=3
2-1=1
2*1=2
2/1=2
Float results:
Numbers: 2.4 and 1.2.
2.4 + 1.2 = 3.6
2.4 - 1.2 = 1.2
2.4 * 1.2 = 2.88
2.4 / 1.2 = 2

In the above program, we have declared a class template Calculator .

The class contains two private members of type T : num1 & num2 , and a constructor to initialize
the members.
We also have add() , subtract() , multiply() , and divide() functions that have the return type T . We
also have a void function displayResult() that prints out the results of the other functions.
In main() , we have created two objects of Calculator : one for int data type and another
for float data type.

Calculator<int> intCalc(2, 1);

Calculator<float> floatCalc(2.4, 1.2);

This prompts the compiler to create two class definitions for the respective data types during
compilation.

C++ Class Templates With Multiple Parameters

In C++, we can use multiple template parameters and even use default arguments for those
parameters. For example,

template <class T, class U, class V = int>

class ClassName {
private:
T member1;
U member2;
V member3;
... .. ...
public:
... .. ...
};

Example 3: C++ Templates With Multiple Parameters

#include <iostream>
using namespace std;

// Class template with multiple and default parameters

template <class T, class U, class V = char>
class ClassTemplate {
private:
T var1;
 U var2;
V var3;

public:
ClassTemplate(T v1, U v2, V v3) : var1(v1), var2(v2), var3(v3) {} // constructor

void printVar() {
cout << "var1 = " << var1 << endl;
cout << "var2 = " << var2 << endl;
cout << "var3 = " << var3 << endl;
}
};

int main() {
// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');
cout << "obj1 values: " << endl;
obj1.printVar();

// create object with int, double and bool types

ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
cout << "\nobj2 values: " << endl;
obj2.printVar();

return 0;
}
Output

obj1 values:
var1 = 7
var2 = 7.7
var3 = c

obj2 values:
var1 = 8.8
var2 = a
var3 = 0

In this program, we have created a class template, named ClassTemplate , with three parameters,
with one of them being a default parameter.

template <class T, class U, class V = char>

class ClassTemplate {
// code
};

Notice the code class V = char . This means that V is a default parameter whose default type
is char .

Inside ClassTemplate , we declare 3 variables var1 , var2 and var3 , each corresponding to one of the
template parameters.

class ClassTemplate {
private:
T var1;
U var2;
V var3;
... .. ...
... .. ...
};

In main() , we create two objects of ClassTemplate with the code

// create object with int, double and char types

ClassTemplate<int, double> obj1(7, 7.7, 'c');

// create object with double, char and bool types

ClassTemplate<double, char, bool> obj2(8, 8.8, false);

Here,

Object T U V

obj1 int double char

obj2 double char bool

For obj1 , T = int , U = double and V = char .

For obj2 , T = double , U = char and V = bool .

C++ Function Template

In this tutorial, we will learn about function templates in C++ with the help of examples.
Templates are powerful features of C++ which allows us to write generic programs.
We can create a single function to work with different data types by using a template.

Defining a Function Template

A function template starts with the keyword template followed by template parameter(s)
inside <> which is followed by the function definition.

template <typename T>

T functionName(T parameter1, T parameter2, ...) {
// code
}

In the above code, T is a template argument that accepts different data types ( int , float , etc.),
and typename is a keyword.
When an argument of a data type is passed to functionName() , the compiler generates a new
version of functionName() for the given data type.
Calling a Function Template
Once we've declared and defined a function template, we can call it in other functions or
templates (such as the main() function) with the following syntax

functionName<dataType>(parameter1, parameter2,...);

For example, let us consider a template that adds two numbers:

template <typename T>

T add(T num1, T num2) {
return (num1 + num2);
}

We can then call it in the main() function to add int and double numbers.

int main() {

int result1;
double result2;
// calling with int parameters
result1 = add<int>(2, 3);
cout << result1 << endl;

// calling with double parameters

result2 = add<double>(2.2, 3.3);
cout << result2 << endl;

return 0;
}

Function Call based on data types

Example: Adding Two Numbers Using Function Templates
#include <iostream>
using namespace std;

template <typename T>

T add(T num1, T num2) {
return (num1 + num2);
}

int main() {
int result1;
double result2;
// calling with int parameters
result1 = add<int>(2, 3);
cout << "2 + 3 = " << result1 << endl;

// calling with double parameters

result2 = add<double>(2.2, 3.3);
cout << "2.2 + 3.3 = " << result2 << endl;

return 0;
}
Output

2 + 3 = 5
2.2 + 3.3 = 5.5