模板实例.docx
《模板实例.docx》由会员分享，可在线阅读，更多相关《模板实例.docx（16页珍藏版）》请在冰点文库上搜索。
模板实例
#include
template
Tabs（Tvalue）
{
returnvalue>0?
value:
-value;
}
voidmain（）
{
intnValue=-1,nResult;
doubledblValue=-1.2,dblResult;
nResult=abs（nValue）;
dblResult=abs（dblValue）;
cout<cout<}
#include
template
classMax//声明类模板Max
{
private:
Titem1,//类型为T,T在该类的对象生成时具体化
item2,
item3;
public:
Max（）{}
Max（Tthefirst,Tthesecond,Tthethird）;
TGetMaxItem（）;//求得3个元素中的最大值并按类型T返回
voidSetItem（Tthefirst,Tthesecond,Tthethird）;//设置类中的3个元素的值
};
template
Max:
:
Max（Tthefirst,Tthesecond,Tthethird）:
item1（thefirst）,item2（thesecond）,item3（thethird）
{
}
template
voidMax:
:
SetItem（Tthefirst,Tthesecond,Tthethird）
{
item1=thefirst;
item2=thesecond;
item3=thethird;
}
template
TMax:
:
GetMaxItem（）
{
Tmaxitem;
maxitem=item1>item2?
item1:
item2;
maxitem=maxitem>item3?
maxitem:
item3;
returnmaxitem;
}
voidmain（）
{
MaxnmyMax（1,2,3）;
MaxdblmyMax（1.2,1.3,-1.4）;
cout<cout<}
或者
#include
templateclassMax//声明类模板Max
{
private:
Titem1,//类型为T,T在该类的对象生成时具体化
item2,
item3;
public:
Max（）{}
Max（Tthefirst,Tthesecond,Tthethird）;
TGetMaxItem（）;//求得3个元素中的最大值并按类型T返回
voidSetItem（Tthefirst,Tthesecond,Tthethird）;//设置类中的3个元素的值
};
templateMax:
:
Max（Tthefirst,Tthesecond,Tthethird）:
item1（thefirst）,item2（thesecond）,item3（thethird）
{
}
templatevoidMax:
:
SetItem（Tthefirst,Tthesecond,Tthethird）
{
item1=thefirst;
item2=thesecond;
item3=thethird;
}
templateTMax:
:
GetMaxItem（）
{
Tmaxitem;
maxitem=item1>item2?
item1:
item2;
maxitem=maxitem>item3?
maxitem:
item3;
returnmaxitem;
}
voidmain（）
{
MaxnmyMax（1,2,3）;
MaxdblmyMax（1.2,1.3,-1.4）;
cout<cout<}
#include
usingnamespacestd;
//首先看结点组织，采用结点类，凡与结点数据和指针操作有关函数作为成员函数
templateclassList;
templateclassNode{
Tinfo;//数据域
Node*link;//指针域
public:
Node（）;//生成头结点的构造函数
Node（constT&data）;//生成一般结点的构造函数
voidInsertAfter（Node*P）;//在当前结点后插入一个结点
Node*RemoveAfter（）;//删除当前结点的后继结点，返回该结点备用
friendclassList;
//以List为友元类，List可直接访问Node的私有成员，与结构一样方便，但更安全
};
templateNode:
:
Node（）{link=NULL;}
templateNode:
:
Node（constT&data）{
info=data;
link=NULL;
}
templatevoidNode:
:
InsertAfter（Node*p）{
p->link=link;
link=p;
}
templateNode*Node:
:
RemoveAfter（）{
Node*tempP=link;
if（link==NULL）tempP=NULL;//已在链尾,后面无结点
elselink=tempP->link;
returntempP;
}
//再定义链表类，选择常用操作：
包括建立有序链表、搜索遍历、插入、删除、取数据等
templateclassList{
Node*head,*tail;//链表头指针和尾指针
public:
List（）;//构造函数，生成头结点（空链表）
~List（）;//析构函数
voidMakeEmpty（）;//清空一个链表，只余表头结点
Node*Find（Tdata）;//搜索数据域与data相同的结点，返回该结点的地址
intLength（）;//计算单链表长度
voidPrintList（）;//打印链表的数据域
voidInsertFront（Node*p）;//可用来向前生成链表，在表头插入一个结点
voidInsertRear（Node*p）;//可用来向后生成链表，在表尾添加一个结点
voidInsertOrder（Node*p）;//按升序生成链表
Node*CreatNode（Tdata）;//创建一个结点（孤立结点）
Node*DeleteNode（Node*p）;//删除指定结点
};
templateList:
:
List（）{
head=tail=newNode（）;
}
templateList:
:
~List（）{
MakeEmpty（）;
deletehead;
}
templatevoidList:
:
MakeEmpty（）{
Node*tempP;
while（head->link!
=NULL）{
tempP=head->link;
head->link=tempP->link;//把头结点后的第一个节点从链中脱离
deletetempP;//删除（释放）脱离下来的结点
}
tail=head;//表头指针与表尾指针均指向表头结点，表示空链
}
templateNode*List:
:
Find（Tdata）{
Node*tempP=head->link;
while（tempP!
=NULL&&tempP->info!
=data）tempP=tempP->link;
returntempP;//搜索成功返回该结点地址，不成功返回NULL
}
templateintList:
:
Length（）{
Node*tempP=head->link;
intcount=0;
while（tempP!
=NULL）{
tempP=tempP->link;
count++;
}
returncount;
}
templatevoidList:
:
PrintList（）{
Node*tempP=head->link;
while（tempP!
=NULL）{
cout<info<<'\t';
tempP=tempP->link;
}
cout<}
templatevoidList:
:
InsertFront（Node*p）{
p->link=head->link;
head->link=p;
if（tail==head）tail=p;
}
templatevoidList:
:
InsertRear（Node*p）{
p->link=tail->link;
tail->link=p;
tail=p;
}
templatevoidList:
:
InsertOrder（Node*p）{
Node*tempP=head->link,*tempQ=head;//tempQ指向tempP前面的一个节点
while（tempP!
=NULL）{
if（p->infoinfo）break;//找第一个比插入结点大的结点，由tempP指向
tempQ=tempP;
tempP=tempP->link;
}
tempQ->InsertAfter（p）;//插在tempP指向结点之前，tempQ之后
if（tail==tempQ）tail=tempQ->link;
}
templateNode*List:
:
CreatNode（Tdata）{//建立新节点
Node*tempP=newNode（data）;
returntempP;
}
templateNode*List:
:
DeleteNode（Node*p）{
Node*tempP=head;
while（tempP->link!
=NULL&&tempP->link!
=p）tempP=tempP->link;
if（tempP->link==tail）tail=tempP;
returntempP->RemoveAfter（）;//本函数所用方法可省一个工作指针，与InsertOrder比较
}
intmain（）{
Node*P1;
Listlist1,list2;
inta[16],i,j;
cout<<"请输入16个整数"<for（i=0;i<16;i++）cin>>a[i];//随机输入16个整数
for（i=0;i<16;i++）{
P1=list1.CreatNode（a[i]）;
list1.InsertFront（P1）;//向前生成list1
P1=list2.CreatNode（a[i]）;
list2.InsertRear（P1）;//向后生成list2
}
list1.PrintList（）;
cout<<"list1长度：
"<list2.PrintList（）;
cout<<"请输入一个要求删除的整数"<cin>>j;
P1=list1.Find（j）;
if（P1!
=NULL）{
P1=list1.DeleteNode（P1）;
deleteP1;
list1.PrintList（）;
cout<<"list1长度：
"<}
elsecout<<"未找到"<list1.MakeEmpty（）;//清空list1
for（i=0;i<16;i++）{
P1=list1.CreatNode（a[i]）;
list1.InsertOrder（P1）;//升序创建list1
}
list1.PrintList（）;
return0;
}
vectora（n）; //按需创建
vectorb（10,1）; //10个元素赋全１，灵活的初始化
vectorc（b）; //整体拷贝创建
vectorf（t,t+5）; //异类拷贝创建
迭代器定义：
Vector :
:
iterator it；
It为定义的迭代器，为指针类型；
b．begin（）;迭代器指向第一个元素位置；
b．end（）;迭代器指向最后一个元素的后一个位置；
b．size（）;求得向量里的元素数；
vectord（b.begin（）,b.begin（）+3）; //局部拷贝创建d为b的前３个元素
a.assign（100）; //动态扩容至100个元素
a.assign（b.begin（）,b.begin（）+3）; //b的前3个元素赋给a
a.assign（4,2）; //a向量含4个元素，全初始化为2
intx=a.back（）; //a的最后一个元素赋给变量x
a.clear（）; //a向量清空（不再有元素）
if（a.empty（））cout<<”empty”; //a判空操作
inty=a.front（）; //a的第一个元素赋给变量y
a.pop_back（）; //删除a的最后一个元素
a.push_back（5）; //a最后插入一个元素，其值为5
a.resize（10）; //a元素个数调至10。
多删少补，其值随机
a.resize（10,2）;//a元素个数调至10。
多删少补，新添元素初值为2
if（a==b）cout<<”equal”; //a与b的向量比较操作
1.基本操作
vector是向量类型，她是一种对象实体，具有值，所以可以看作是变量。
她可以容纳许多其他类型的相同实体，
如若干个整数，所以称其为容器。
Vector是C++STL（标准模板类库）的重要一员，使用她时，只要包括头文件#include即可。
vector可以有四种定义方式：
vector是模板形式，尖括号中为元素类型名，她可以是任何合法的数据类型。
（1）vectora（10）;
//定义了10个整数元素的向量，但并没有给出初值，因此其值是不确定的。
（2）vectorb（10,1）;
//定义了10个整数元素的向量，且给出每个元素的初值为1。
这种形式是数组望尘莫及的，
//数组只能通过循环来成批的赋给相同初值。
（3）vectorc（b）;
//用另一个现成的向量来创建一个向量。
（4）vectord（b.begin（）,b.begin（）+3）;
//定义了其值依次为b向量中第0到第2个（共3个）元素的向量。
因此，创建向量时，不但可以整体向量复制性赋值，还可以选择其他容器的部分元素来定义向量和赋值。
特别的，向量还可以从数组获得初值。
例如：
inta[8]={2007,9,24,2008,10,14,10,5};
vectorva（a,a+8）;
上面第（4）种形式的b.begin（）、b.end（）是表示向量的起始元素位置和最后一个元素之外的元素位置。
向量元素位置也属于一种类型，称为遍历器。
遍历器不单表示元素位置，还可以在容器中前后挪动。
每种容器都有对应的遍历器。
向量中的遍历器类型为：
vector:
:
iterator
因此要输入向量中所有元素，可以有两种循环控制方式：
for（inti=0;icout<for（vector:
:
iteratorit=a.begin（）;it!
=a.end（）;++it）//第二种方法
cout<<*it<<"";
第一种方法是下标方式，a[i]是向量元素操作，这种形式和数组一样；
第二种方法是遍历器方式，*it是指针间访形式，它的意义是it所指向的元素值。
a.size（）是向量中元素的个数，a.begin（）表示向量的第一个元素，这种操作方式是一个对象捆绑一个函数调用，
表示对该对象进行某个操作。
类似这样的使用方式称为调用对象a的成员函数，这在对象化程序设计中很普遍。
向量中的操作都是通过使用成员函数来完成的。
它的常用操作有：
a.assign（b.begin（）,b.begin（）+3）; //b向量的0~2元素构成向量赋给a
a.assign（4,2）; //使a向量只含0~3元素，且赋值为2
intx=a.back（）; //将a的最后一个向量元素值赋给整数型变量x
a.clear（）; //a向量中元素清空（不再有元素）
if（a.empty（））cout<<"empty"; //a.empty（）经常作为条件，判断向量是否为空
inty=a.front（）; //将a的第一个向量元素值赋给整型变量y
a.pop_back（）; //删除a向量的最后一个元素
a.push_back（5）; //在a向量最后插入一个元素，其值为5
a.resize（10）; //将向量元素个数调至10个。
多则删，少则补，其值随机
a.resize（10,2）; //将向量元素个数调至10个。
多则删，少则补，其值为2
if（a=b）cout<<"epual"; //向量的比较操作还有!
=,<,<=, >,>=
除此之外，还有元素的插入与删除、保留元素个数、容量观察等操作。
用STLvector来创建二维数组
通常情况下，采用向量创建二维数组的方法有两种：
方法一：
1introw=3;//行数
2intcolumn=4;//列数
3vector>arry2（row）;//定义一个三行四列的数组
4for（inti=0;i5{
6arry2[i].resize（column）;
7}
方法二：
vector>arry2（row,vector（column））;
#include
#include
#include
usingnamespacestd;
boolcmp（inta,intb）;
voidmain（）
{
inti;
vectora;
for（i=1;i<=10;i++）
a.push_back（i）;
for（i=0;icout<cout<vector:
:
iteratorit;
for（it=a.begin（）;it!
=a.end（）;it++）
cout<<*it;
cout<intx=a.back（）;
cout<vectorc（a）;
inty=c.front（）;
cout<a.pop_back（）;
for（it=a.begin（）;it!
=a.end（）;it++）
cout<<*it;
cout<a.resize（12）;
for（it=a.begin（）;it!
=a.end（）;it++）
cout<<*it;
cout<a.resize（15,2）;
for（it=a.begin（）;it!
=a.end（）;it++）
cout<<*it;
cout<c.clear（）;
if（c.empty（））
cout<<"向量已为空！
\n";
vectord（a.begin（）,a.begin（）+5）;
for（it=d.begin（）;it!
=d.end（）;it++）
cout<<*it;
cout<s
升级会员 