Data Structures

4. Function Templates

4-Function Templates 1
Function Overloading

• Function to print an array of integer elements

void printArray(int* array, int size)

{
for ( int i = 0; i < size; i++ )
cout << array[ i ] << “, ”;
}

• Function to print an array of characters

void printArray(char* array, int size)
{
for ( int i = 0; i < size; i++ )
cout << array[ i ] << “, ”;
}

4-Function Templates 2
Function Overloading

• Function to print an array of doubles

void printArray(double* array, int size)
{
for ( int i = 0; i < size; i++ )
cout << array[ i ] << “, ”;
}

• Now if we want to change the way function prints the array

– From 1, 2, 3, 4, 5
– To 1 -2- 3 -4 -5

4-Function Templates 3
Function Overloading

• C++ allows the programmer to overload a function name

• Several functions with the same name but different parameter lists
– Parameter list determines which function will execute.

• Programmer must give the definition of each function

• Can we overload functions with a single code segment?

– Leave the job of generating code for separate functions for the
compiler

4-Function Templates 4
C++ Classes

• Consider the Array class that wraps an array of integers

class Array {
int* pArray;
int size;
public:
…
};

• What if we want an Array class that wraps arrays of double?

class Array {
double* pArray;
int size;
public:
…
};
4-Function Templates 5
C++ Classes

• What if we want an Array class that wraps arrays of Boolean?

class Array {
bool* pArray;
int size;
public:
…
};

• Now if we want to add a function sum to Array class?

– We have to change all the three classes

4-Function Templates 6
Generic Programming

• Programs containing generic abstractions

• Generic program abstraction (function, class) can be parameterized

with a type
– Abstractions can work with many different types of data

• Algorithms are written in terms of types to-be-specified-later

– Instantiated when needed for specific types provided as parameters

• Advantages
– Reusability
– Writability
– Maintainability

4-Function Templates 7
Templates

• In C++ generic programming is done using templates

• Two types of templates

– Function Templates
– Class Templates

• Compiler generates different type-specific copies from a single

template
template <class Type>
function or class declaration;

template <typename Type>

function or class declaration;

4-Function Templates 8
Function Templates

• A function template can be parameterized to operate on different

types of data

• Declaration:

template< class T >

void funName( T x );

template< typename T >

void funName( T x );

template< class T, class U, … >

void funName( T x, U y, … );

4-Function Templates 9
Example

• function template to print an array having almost any type of data

template< typename T >
void printArray( T* array, int size ) {
for ( int i = 0; i < size; i++ )
cout << array[ i ] << “, ”;
}

int main() {
int iArray[5] = { 1, 2, 3, 4, 5 };
printArray( iArray, 5 );
// Instantiated for int[]

char cArray[3] = { ‘a’, ‘b’, ‘c’ };

printArray( cArray, 3 );
// Instantiated for char[]
return 0;
}
4-Function Templates 10
Explicit Type Parameterization

• A function template may not have any parameter

template <typename T>
T getInput() {
T x;
cin >> x;
return x;
}
int main() {
int x;
x = getInput(); // ??

double y;
y = getInput(); // ??
}

4-Function Templates 11
Explicit Type Parameterization

• A function template may not have any parameter

template <typename T>
T getInput() {
T x;
cin >> x;
return x;
}
int main() {
int x;
x = getInput(); // Error!

double y;
y = getInput(); // Error!
}

4-Function Templates 12
Explicit Type Parameterization

• A function template may not have any parameter

template <typename T>
T getInput() {
T x;
cin >> x;
return x;
}
int main() {
int x;
x = getInput< int >();

double y;
y = getInput< double >();
}

4-Function Templates 13
User-Defined Specialization

• A template may not handle all the types successfully

• Explicit specializations might be needed for specific type(s)

template< typename T >

bool isEqual( T x, T y ) {
return ( x == y );
}

int main( ) {
isEqual( 5, 6 ); // OK
isEqual( 7.5, 7.5 ); // OK
isEqual( “abc”, “xyz” ); // Logical Error!
return 0;
}

4-Function Templates 14
User-Defined Specialization
template< typename T >
bool isEqual( T x, T y ) {
return ( x == y );
} General Template

template< >
bool isEqual< const char* >(const char* x, const char* y ) {
return ( strcmp( x, y ) == 0 );
}
User Specialization

int main( ) {
isEqual( 5, 6 ); // Target: General Template
isEqual( 7.5, 7.5 ); // Target: General Template
isEqual( “abc”, “xyz” ); // Target: User Specialization
return 0;
} 4-Function Templates 15
Multiple Type Arguments

template< typename T, typename U >

T my_cast( U u ) {
return (T)u;
}

int main() {
double d = 10.5674;
int j = my_cast( d ); //Error
int i = my_cast< int >( d );
return 0;
}

4-Function Templates 16
User-Defined Types

• Besides primitive types, user-defined types can also be passed as

type arguments to templates
• Compiler performs static type checking to diagnose type errors

• Example: Consider String class without overloaded operator “==“

class String {
char* pStr;
. . .
// Operator “==“ not defined
};

4-Function Templates 17
User-Defined Types

template< typename T >

bool isEqual( T x, T y ) {
return ( x == y );
}

int main() {
String s1 = “xyz”, s2 = “xyz”;
isEqual( s1, s2 ); // Error!
return 0;
}

4-Function Templates 18
User-Defined Types

class String {
char* pStr;
. . .
friend bool operator ==(const String&, const String& );
};

bool operator ==( const String& x, const String& y ) {

return strcmp(x.pStr, y.pStr) == 0;
}

int main() {
String s1 = “xyz”, s2 = “xyz”;
isEqual( s1, s2 ); // OK
return 0;
}

4-Function Templates 19
Overloading vs. Templates

Function overloading
• Different data types, similar operation
• Example
– ‘+’ operation is overloaded for different operand types

Function templates
• Different data types, identical operation
• Example
– A single function template can calculate sum of array of many types

4-Function Templates 20
Overloading vs. Templates – Example

String operator +( const String& x, const String& y ) {

String tmp;
tmp.pStr = new char[strlen(x.pStr) + strlen(y.pStr) + 1 ];
strcpy( tmp.pStr, x.pStr );
strcat( tmp.pStr, y.pStr );
return tmp;
}

String operator +( const char * str1, const String& y ) {

String tmp;
tmp.pStr = new char[ strlen(str1) + strlen(y.pStr) + 1 ];
strcpy( tmp.pStr, str1 );
strcat( tmp.pStr, y.pStr );
return tmp;
}

4-Function Templates 21
Overloading vs. Templates – Example

template< class T >

T sum( T* array, int size ) {
T sum = 0;

for (int i = 0; i < size; i++){

sum = sum + array[i];
}

return sum;
}

4-Function Templates 22
Any Question So Far?

4-Function Templates 23