7Template

Macro presents the possibility for serious side effects and do not enable the compiler to perform type checking.
template<class T> template <class T> T max(T x,T y) { return (x>y)? x:y; } void main() { int i1,i2; double d1,d2; cout<<max(i1,i2); cout<<max(d1,d2); }
Template<class T> String {/*…..*/}; //class template Class String {/*…*/}; //error double definition
2. Template Instantiation
The process of generating a class declaration from a template class and a template argument is often called template instantiation.
int max(double d, int i){ return max<double>(d,i); } int max(int i, int j){ return max<int>(i,j); } template<class T> T max(T,T); const int s=7; void k( ) { max(1,2); //ok max<int>(1,2) max(‘a’,’b’); //ok max(2.9,4.7); //ok max(s,7); //ok max(‘a’,1); //error max(2.7,4); //error }
template<class T, int i> T& lookup(Buffer<T, i>& b,const char* p); class Record{}; Record& f(Buffer<Record,128>& buf, const char* p) { return lookup(buf, p); }
7.1 Class Template
1. Definition of a Template
Define a class as a template. Thus, the data members and the arguments and returning values of member functions in the class can be taken in a parameter. A class generated from a class template is a perfectly ordinary class.
1. Function Template Parameter
A compiler can deduce type and non-type argument from a call, provided the function argument list uniquely identifies the the set of template argument.
Class template
const int S=10; template<class T> class stack{ public: stack(); ~stack(); void Push(T n); T Pop(); private: int tos; T st[S]; };
template<class T> stack<T>::stack() { tos=1; } template<class T> void stack<T>::Push(T n) { if (tos>S) return; st[tos]=n; tos++; }
void main() { stack<int> ist; for(int i=0;i<5;i++) ist.Push(i); for(i=0;i<5;i++) cout<<ist.Pop(); }
stack<char> cst; cst.Push('a'); cst.Push('b'); cst.Push('c'); cst.Pop();
const int S=10; class stack{ public: stack(); ~stack(); void Push(int n); int Pop(); private: int tos; int st[S]; }; stack::stack() { tos=1; }
void stack::Push(int n) { if (tos>S) return; st[tos]=n; tos++; } int stack::Pop() { if (tos>0) { tos--; return st[tos];} else return 0; }
void main() { myclass<int, double> ob(10,21.5); ob.show(); }
7.2 Function Templates
Overloaded functions are normally used by to perform similar operations on different types of data. If the operations are identical for each type, this may be performed more compactly and conveniently using functions templates.
#define max(x,y) ((x>y)? x:y;)
int max(int x, int y) { return (x>y)? x:y; } float max(float x, float y) { return (x>y)? x:y; } double max(double x, double y) { return (x>y)? x:y; }
Template class
3. Template Parameters
A template can take type parameters, parameters of ordinary types such as int, and template parameters.
template<class T, int elements> class stack{ public: stack(); ~stack(); stack<int, 100> ist; void Push(T n); T Pop(); private: int tos; T st[elements]; // array to hold stack };
2. Function Template Overloading
One can declare several function templates with the same name and even declare a combination of function templates and ordinary functions late
Templates provide direct support for generic programming, that is, programming using types as parameters. Template mechanism allows a type to be a parameter in the definition of a class or a function. Templates provide a simple way to represent a wide range of general concepts and simple ways to combine them. Templates are one of C++’s capabilities for software reuse.
A template parameterizes the definition of a type or a function with another type. Code implementing the template is identical for all parameter types, as is most code using the template. Much code for different implementation of the abstract class can be shared in class hierarchies, and most code using the abstract class does not depend on its implementation.
template<class T> T stack<T>::Pop() { if (tos>0) { tos--; return st[tos];} else return 0; } template<class T> stack<T>::~stack() { }