Templates

With templates a class or function can be created that works with different data types.

Function Templates

The function template can work with different type of arguments.

Syntax for defining Template Function:

TempName funcName(T arg1, T arg2 ...) { // code }

Syntax for calling Template Function:

funcName<argTypes>(args)

Here's an example:

#include <iostream> using namespace std; template<typename T> T maxElem(T a, T b) { if (a > b) { return a; } return b; } void main() { int intElem1 = 3; int intElem2 = 10; cout << maxElem<int>(intElem1, intElem2) << endl; double doubleElem_1 = 1.4; double doubleElem_2 = 3.7; cout << maxElem<double>(doubleElem_1, doubleElem_2) << endl; char charElem1 = 'a'; char charElem2 = 'z'; cout << maxElem<char>(charElem1, charElem2) << endl; cout << maxElem<int>(charElem1, charElem2) << endl; }

Output:

10 3.7 z 122

Explanation:

• At lines 5 - 14 a template that returns the bigger of the 2 arguments is defined.
• At line 21 the template function is called for integer arguments, line 26 - double, line 31 - char.
• When chars are passed to the template, the chars arguments are compared by ascii code. Thus z is consider bigger than a.
• Line 33 is a bit more interesting. The arguments are of type char but are defined as integer. So the char arguments are converted to their ascii code.

Class Templates

Class templates can work with members of different types.

Syntax for defining class templates:

template <class T> class Calculator { // defining member: T memberName; // code }

Syntax for creating class template object (via default constructor):

ClassName<argTypes>objName

Example:

#include <iostream> using namespace std; template <class T> class Calculator { private: T num1; T num2; public: // parameterized constructor: Calculator(T num1Val, T num2Val) { num1 = num1Val; num2 = num2Val; } T add() { return num1 + num2; } T subtract() { return num1 - num2; } T multiply() { return num1 * num2; } T divide() { return num1 / num2; } }; void main() { Calculator<int> intCalc(3, 8); Calculator<float> floatCalc(2.4, 1.2); Calculator<double> doubleCalc(3.9, 1.2); cout << "3 + 8 = " << intCalc.add() << endl; cout << "2.4 - 1.2 = " << floatCalc.subtract() << endl; cout << "3.9 * 1.2 = " << doubleCalc.multiply() << endl; }

Output:

3 + 8 = 11 2.4 - 1.2 = 1.2 3.9 * 1.2 = 4.68

Explanation:

• At lines 39 - 41 are created 3 template class object of 3 types (int, float, double).
• Lines 44, 47 and 50 call members of the class.

Why using templates?

They are suitable for larger apps are are flexible.

With them one code can be executed for different types of arguments / class members.

Instead of defining many functions with the same name and logic but different types of arguments, a template can be used.

A value swapping program:

#include <iostream> #include <string> using namespace std; void swapVariables(int &num1, int &num2) { int buffer = num2; num2 = num1; num1 = buffer; } void swapVariables(string &str1, string &str2) { string buffer = str2; str2 = str1; str1 = buffer; } void main() { int num1 = 1; int num2 = 2; string str1 = "a"; string str2 = "b"; cout << "Before swap: " << endl; cout << num1 << " " << num2 << endl; cout << str1 << " " << str2 << endl; swapVariables(num1, num2); swapVariables(str1, str2); cout << "After swap: " << endl; cout << num1 << " " << num2 << endl; cout << str1 << " " << str2 << endl; }

Output:

Before swap: 1 2 a b After swap: 2 1 b a

The program above can be rewritten using templates like this:

#include <iostream> #include <string> using namespace std; template<typename T> void swapValue(T &a, T &b) { T buffer = b; b = a; a = buffer; } void main() { int num1 = 1; int num2 = 2; string str1 = "a"; string str2 = "b"; cout << "Before swap: " << endl; cout << num1 << " " << num2 << endl; cout << str1 << " " << str2 << endl; swapValue<int>(num1, num2); swapValue<string>(str1, str2); cout << "After swap: " << endl; cout << num1 << " " << num2 << endl; cout << str1 << " " << str2 << endl; }

Output:

Before swap: 1 2 a b After swap: 2 1 b a