Function Template Overloading

A template function may be overloaded either by template functions or ordinary functions. In such cases, the overloading resolution is accomplished using following steps:

• Call an ordinary function that has an exact match.
• If a match for an ordinary function is not found, call a template function that could be created with an exact match.

An error is generated if no match is found. Note that no automatic conversions are applied to arguments on the template functions. The program shows how a template function is overloaded with an explicit function.

Member Function Templates

When we created a class template for vector, in the previous tutorial, all the member functions were defined as inline which was not necessary. We could have defined them outside the class as well. But remember that the member functions of the template classes themselves are parameterized by the type argument (to their template classes) and therefore these functions must be defined by the function templates. It takes the following general form:

template<class T> return-type class name <T> :: function-name(arguments) { // function body }

Example:

#include<iostream.h> template<class T> class vector { private: T *v; int size; public: vector(int m); vector(T *a, int size); T operator*(vector &y); } template<class T> vector<T>::vector(int m) { v=new T [size = m]; for(int i=0; i<size; i++) v[i] = 0; } template<class T> vector<T>::vector(T *a, int size) { for(int i=0; i<size; i++) v[i] = a[i]; } template<class T> T vector<T>::operator*(vector &y) { T sum = 0; for(int i=0; i<size; i++) sum += this->v[i] * y->v[i]; return sum ; } void main() { int x[3] = {1,2,3}; int y[3] = {4,5,6}; vector<int> v1; vector<int> v2; v1=x; v2=y; int R=v1*v2; cout<<"R = "<<R; }

Non-Type Template Arguments

We have seen that a template can have multiple arguments. It is also possible to use non-type arguments. That is, in addition to the type argument T, we can also use other arguments such as strings, functions, constant expressions, and built-in types.

Consider the following example:

template <class T, int size> class array { T a[size]; ———– }

This template supplies the size of the array as an argument. This implies that the size of the array is known to the compiler at the compile time itself. The arguments must be specified whenever a template class is created,

Example:

array <int, 10> a1 // array of 10 integers array <float, 5> a2 // array of 5 floats array <char, 20> a3 // string of size 20