数据结构预备知识（三）

模板（template）通用数据类

模版函数 
          通用函数 
2.   类模版  
          通用数据类型

模版函数 通用函数 

   几个形式上完全相同的函数，只有
   参数类型和返回值类型不同，可以
   写成通用函数，也叫模版函数。

例. int max(int a, int b)       {return a>b?a:b；}

float max(float a, float b)
  {return a>b?a:b；}
  
char max(char a, char b)
  {return a>b?a:b；}


可以统一写成一个模版函数

template <class T>

T  max(T a, T b)
{return a>b?a:b；}

这里 T 是类型参数
可以用任意一个标识符
模版函数的调用

对不同的参数都可以调用函数max
int a, b;
char x,y;
a=3; b=5; x= 'A'; y='b';
a=max(a, b);  \\有意义
x=max(x, y);  \\有意义


参数可以用字符串，甚至复杂的结构变
量，对象，只要事先定义大小关系。

2.类模版  通用数据类型

//array.h      例. 通用数组 抽象数组类型
 template <class T>
 class  Array
 {  T *alist;                        //指针数据 表示一个数组
    int  size;                             //表示数组长度  
   public:
    Array(int s=50)                    //构造函数
    Array(const Array<T>&X); //拷贝构造函数
   ~Array( ){delete[ ] element;} //析构函数
    Array<T>&operator=(const Array<T>&X);// 赋值函数重载
    T& operator[ ](int i)；         //一元运算[ ]重载 下标函数
    operator T*( )const;            //强制类型转换,将当前
                                                //对象变成指向它的首地址的指针，
    int ArraySize( )const;        //取数组长
    void Resize(int sz);            //数组长重定义 
    friend ostream& operator<<(ostream&, const Array<T>&);
                                        //输出操作重载
   }；

template <class T>
 class  Array
 {  T *alist;    //指针数据 表示一个数组
    int  size;     //表示数组长度  
   public:
    Array(int s=50)                    //构造函数
    Array(const Array<T>&X); //拷贝构造函数
   ~Array( ){delete[ ] element;} //析构函数

    Array<T>&operator=(const Array<T>&X);
                                            // 赋值函数重载
    T& operator[ ](int i)；  //一元运算[ ]重载 
                                          //下标函数
    operator T*( )const;     //强制类型转换,将当前
                     //对象变成指向它的首地址的指针，
    int ArraySize( )const;        //取数组长
    void Resize(int sz);            //数组长重定义 
    friend ostream& operator<< (ostream&, 
                           const Array<T>&);   //输出操作重载   
}；

//构造函数 

template <class T>
Array<T>::Array(int sz)
{   size = sz;
    alist = new T[size];    
    if (alist == 0)
        {cout<< “内存不够”；
            return; }
}

// 析构函数 destructor

template <class T>
Array<T>::~Array(void)
{ 
    delete [ ] alist;
}
// copy constructor 拷贝构造函数
template <class T>
Array<T>::Array(const Array<T>& X)
{  int n = X.size; //取对象X的长度作为当前对象的长 
    size = n;
    alist = new T[n];           // allocate dynamic array
    if (alist == 0)               //作正确性检查
        {cout<<“内存不够”；return;}
    
    //copy array items from X to current object  
    T* srcptr = X.alist;    // address at start of X.alist
    T* destptr = alist;     // address at start of alist
    while (n--)             // copy list
        *destptr++ = *srcptr++;
 }

template <class T>    //赋值函数重载
Array<T>& Array<T>::operator= (const Array<T>& X)
{ 
    int n = X.size; // 取X的长度 
    
    if (size != n)    // 若长度不同，重新分配内存
       {delete [ ] alist;        // destroy original memory
          alist = new T[n];       // allocate a new array
         if (alist == 0)
            {cout<<“内存不够”；return;}
          size = n; 
         }
// 将对象X的元素逐个拷贝到当前对象
// copy array items from X to current object
   T* destptr = alist;
   T*  srcptr =X.alist;
    while (n--) 
        *destptr++ = *srcptr++;


// 返回当前对象的值
//return reference to the current object
    return *this;
}

//一元运算[ ]重载 下标函数 // overloaded index operator
template <class T>
T& Array<T>::operator[] (int n)
{
   // do array bounds checking
   if (n < 0 || n > size-1)
      {cout<< "下标超界”；return;}
  
  // return the element from the private array list
       return alist[n];
}
 

//强制类型转换,将当前对象 //变成指向它的首地址的指针，
// pointer conversion operator
template <class T>
Array<T>::operator T* ( ) const
{
    // return address of private array in the //current object
    return alist;
}

//取当前对象的长
template <class T>
int Array<T>::ListSize( ) const
{
    return size;
}

//改变当前对象的长度 // resize operator
template <class T>
void Array<T>::Resize(int sz)
{ // test new size parameter; terminate if size <= 0
    if (sz <= 0) 
        {cout<< “长度不能小于等于0”；return;}
    // nothing to do if size hasn't changed
    if (sz == size)   return;
  // request new memory and verify system response
    T* newlist = new T[sz];
    if (newlist == 0)
        {cout<<“内存不够”；return;}
        int n = (sz <= size) ? sz : size;//n取较小的一个
    // copy n array items from old to new memory
    T* srcptr = alist;      // address at start of alist
    T* destptr = newlist;   // address at start of newlist
    while (n--)             // copy list
        *destptr++ = *srcptr++;
    delete[] alist;     // delete old list
    // reset alist to point at newlist and update the size
    alist = newlist;
    size = sz;
}

ostream& operator<<(ostream& out, const Array<T>& a)
{ for(int i=0; i<a.size; i++)
      out<<a.alist[i]<< ‘  ’ ;
  out<<endl;
}

//通用数组类的测试

#include<iostream.h>
#include "array.h"
void  main(void )
{  Array<int> a(20);//定义长为0的整数数组
   for(int i=0;i<20;i++)
    a[i]=i+1;  //下标函数返回值是类型T的引用
                   //可以写在表达式的左边
   Array<int>b(a), c=a; //用拷贝构造函数，
                                      //赋值函数建立新对象
     cout<<a<<b<<c;
   }

还可以定义字符数组，记录类型数组，复数类的数组，二维数组，三维数组等等，方法与C语言相同。

#include<iostream.h>
#include "array.h"
#include “complex.h" 
void  main(void )
{  Array<complex> a(20);
     complex s(1,2);
   for(int i=0;i<20;i++)
      a[i]=a[i]+s; 
   Array<complex>b(a), c=a; 
    cout<<a<<b<<c;
}

3． 多于一个参数的模版

模版可以有不止一个参数，可以是某
个简单类型参数，也可以是通用参数。

例 template<class T, class S>  

class Node

 {  Node<T,S> *previous, *next;
            T  *T_data;
            S   *S_data;
      Public:
        Node(Node<T,S>*, Node<T,S>*,T*,S*);
        ~Node( );
    }   

template <class T, class S>
Node<T,S>::Node(Node<T,S>*p,   
                      Node<T,S>*q, T*t, S* s)
  { previous=p; next=q; 
    T_data=t; S_data=s;}


template<class T,class S>
Node<T,S>::~Node( )
 {delete T_data; delete S_data;}

4．类模版可以嵌套

 template<class T，class S>  
 class List
{  Node<T,S> *head, *current;
  public:
    List( );
   void  Insert( T*, S*);
   void  Remove(T*, S*);
   ~List( );
 }