数据结构预备知识(三)
来源:互联网 发布:淘宝天天特价报名费用 编辑:程序博客网 时间:2024/04/28 06:14
模板(template)通用数据类
模版函数
通用函数
2. 类模版
通用数据类型
通用函数
2. 类模版
通用数据类型
模版函数 通用函数
几个形式上完全相同的函数,只有
参数类型和返回值类型不同,可以
写成通用函数,也叫模版函数。
例. int max(int a, int b) {return a>b?a:b;}
参数类型和返回值类型不同,可以
写成通用函数,也叫模版函数。
例. 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;}
可以统一写成一个模版函数
{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 是类型参数
可以用任意一个标识符
模版函数的调用
{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); \\有意义
参数可以用字符串,甚至复杂的结构变
量,对象,只要事先定义大小关系。
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;} //析构函数
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>&); //输出操作重载
};
// 赋值函数重载
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
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];
}
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;
}
// 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;
}
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;
}
//通用数组类的测试
{ 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 "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;
}
#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;}
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( );
}
class List
{ Node<T,S> *head, *current;
public:
List( );
void Insert( T*, S*);
void Remove(T*, S*);
~List( );
}
0 0
- 数据结构预备知识(三)
- 数据结构预备知识(一)
- 数据结构预备知识(二)
- 数据结构预备知识(四)
- (三)预备知识----指针
- 《数据结构》(c++版)预备知识
- 数据结构预备知识
- 【初识数据结构】预备知识
- 数据结构预备知识总结
- ASP.NET预备知识(三)
- 汇编预备知识(三)
- C#数据结构---- 数学预备知识
- 1:数据结构之预备知识
- 第一章(预备知识)
- 03-数据结构_预备知识-指针
- 04-数据结构_预备知识-结构体
- 数据结构笔记 预备知识之指针
- 数据结构java版一 预备知识
- 矩阵快速幂-HDU5015
- javaweb 学习笔记
- jhhh
- Set 到 Map的扩展--- 继承set
- jquery.cookie() 方法的使用(读取、写入、删除)
- 数据结构预备知识(三)
- Logistic回归与梯度上升算法
- mysql 将查询结果导入表中
- linux mlockall
- Windows下 NGINX PHP 以及 "No input file specified"
- sql 去除重复记录只取一条
- 关于Genymotion下载模拟器失败
- 胡水生:中小型企业如何应对互联网的发展
- Struts2案例--开发权限验证拦截器