列车时刻查询系统设计c课程设计报告Word下载.docx
《列车时刻查询系统设计c课程设计报告Word下载.docx》由会员分享，可在线阅读，更多相关《列车时刻查询系统设计c课程设计报告Word下载.docx（29页珍藏版）》请在冰豆网上搜索。
+GetTi（）:
Time
+SelectNum（Num[]:
char）:
int
+SelectPlace（Place1[]:
char,Place2[]:
+Show（）:
void
ii）Ztrain类的UML图
Ztrain
+Ztrain（）
+Ztrain（Num[]:
char,Eo[]:
+~Ztrain（）
ii）Ttrain类的UML图
Ttrain
+Ttrain（）
+Ttrain（Num[]:
+~Ttrain（）
iii）Dtrain类的UML图
Dtrain
+Dtrain（）
+Dtrain（Num[]:
+~Dtrain（）
iv）Ktrain类的UML图
Ktrain
+Ktrain（）
+Ktrain（Num[]:
Time）
+~Ktrain（）
三、实现流程分析：
i）Train类的声明与实现：
structTime
{
inthour;
intminute;
};
classTrain
private:
chartrainNum[10];
charEozoic[20];
charTerminus[20];
TimestarTime;
public:
Train（）{}
Train（charNum[],charEo[],charTe[],TimeTi）;
Train（constTrain&
x）;
~Train（）{}
operator=（constTrain&
l）;
char*GetNum（）;
char*GetEo（）;
char*GetTe（）;
TimeGetTi（）;
intSelectNum（charNum[]）;
intSelectPlace（charPlace1[],charPlace2[]）;
voidShow（）;
iv）Ztrain、Ttrain、Dtrain、Ktrain类的声明与实现：
classZtrain:
virtualpublicTrain
Ztrain（）{}
Ztrain（charNum[],charEo[],charTe[],TimeTi）;
~Ztrain（）{}
classTtrain:
Ttrain（）{}
Ttrain（charNum[],charEo[],charTe[],TimeTi）;
~Ttrain（）{}
classDtrain:
publicTtrain,publicZtrain
Dtrain（）{}
Dtrain（charNum[],charEo[],charTe[],TimeTi）;
~Dtrain（）{}
classKtrain:
publicTrain
Ktrain（）{}
Ktrain（charNum[],charEo[],charTe[],TimeTi）;
~Ktrain（）{}
iii）主函数的实现：
voidShowMenu（）;
/*菜单显示*/
voidCreat（）;
/*建立字符串工具箱*/
voidSerchAsPlace（）;
//按站台查询
voidSerchAsNum（）;
//按车次查询
voidDisplay（）;
//显示所有信息
voidSave（）;
//将链表信息保存到文件中
voidOpen（）;
//将文件中的信息读到链表中
LinkedList<
Train>
List;
intmain（void）
charx;
boolquit=false;
List.ClearList（）;
Open（）;
while（!
quit）
{
ShowMenu（）;
cin>
>
x;
switch（x）
case'
a'
:
cout<
<
"
wode"
;
system（"
cls"
）;
Creat（）;
break;
b'
SerchAsPlace（）;
c'
SerchAsNum（）;
d'
Display（）;
e'
Save（）;
case'
f'
quit=true;
default:
}
//system（"
return1;
}
/*主菜单*/
voidShowMenu（）
cout<
\n*******************************************\n"
a、添加列车时刻表\n"
b、按始发站终点站查询信息\n"
c、按车次查询列车信息\n"
d、显示所有列车信息\n"
e、保存列车信息\n"
f、退出\n"
请选择"
}
voidCreat（）
intm=1;
charstr1[10];
inthour,minute;
charstr2[20],str3[20];
Trainp;
Timey1;
intn;
while（m==1）
cout<
请输入列车的类型：
（，直达快车2，动车组3，特快车4，快车）"
endl;
cin>
n;
请输入车次：
str1;
请输入发车时间（时和分中间用空格隔开）：
hour>
minute;
y1.hour=hour;
y1.minute=minute;
请输入始发站：
str2;
请输入终点站：
str3;
if（n==1）
{
Ztraint（str1,str2,str3,y1）;
p=t;
}
elseif（n==2）
Dtraint（str1,str2,str3,y1）;
elseif（n==3）
Ttraint（str1,str2,str3,y1）;
elseif（n==4）
Ktraint（str1,str2,str3,y1）;
else
cout<
输入错误！
List.InsertRear（p）;
是否想继续输入：
，是.2,否。
\n"
m;
pause"
voidSerchAsPlace（）
longpos=0;
List.Reset（）;
List.EndOfList（））
p=List.Data（）;
pos=p.SelectPlace（str2,str3）;
List.Next（）;
if（pos==0）
没有此信息"
voidSerchAsNum（）
charstr1[20];
pos=p.SelectNum（str1）;
voidDisplay（）
p.Show（）;
四、个性功能介绍：
i）链表模板类的声明与实现：
/*节点类*/
template<
classT>
classNode
private:
Node<
T>
*next;
public:
Tdata;
Node（constT&
item,Node<
*ptrnext=NULL）;
voidInsertAfter（Node<
*p）;
*DeleteAfter（）;
*NextNode（）const;
Node<
Node（constT&
*ptrnext）:
data（item）,next（ptrnext）
{}
*Node<
NextNode（）const
returnnext;
voidNode<
InsertAfter（Node<
*p）
p->
next=next;
next=p;
DeleteAfter（）
Node<
*tempPtr=next;
if（next==NULL）
returnNULL;
next=tempPtr->
next;
returntempPtr;
//链表类
classLinkedList
*head,*tail;
*prevPtr,*currPtr;
intsize;
intposition;
*GetNode（constT&
voidFreeNode（Node<
voidCopyList（constLinkedList<
&
L）;
LinkedList（）;
LinkedList（constLinkedList<
~LinkedList（）;
LinkedList<
operator=（constLinkedList<
intListSize（）const;
intListEmpty（）const;
voidReset（intpos=0）;
voidNext（）;
intEndOfList（）const;
intCurrentPosition（）const;
voidInsertFront（constT&
item）;
voidInsertRear（constT&
voidInsertAt（constT&
voidInsertAfter（constT&
TDeleteFront（）;
voidDeleteAt（）;
T&
Data（void）;
voidClearList（void）;
*LinkedList<
GetNode（constT&
*ptrnext）
*p;
p=newNode<
（item,ptrnext）;
if（p==NULL）
cout<
"
Memoryallocationfailure!
exit
（1）;
returnp;
voidLinkedList<
FreeNode（Node<
deletep;
CopyList（constLinkedList<
L）
//P用来遍历L
*p=L.head;
intpos;
//将L中的每一个元素插入到当前链表最后
while（p!
=NULL）
InsertRear（p->
data）;
p=p->
NextNode（）;
//如果链表空,返回
if（position==-1）
return;
//在新链表中重新设置prevPtr和currPtr
prevPtr=NULL;
currPtr=head;
for（pos=0;
pos!
=position;
pos++）
prevPtr=currPtr;
currPtr=currPtr->
LinkedList（void）
head=NULL;
tail=NULL;
size=0;
position=0;
LinkedList（constLinkedList<
head=tail=NULL;
prevPtr=currPtr=NULL;
size=0;
position=-1;
CopyList（L）;
ClearList（）
*currPosition,*nextPosition;
currPosition=head;
while（currPosition!
//取得下一结点的地址并删除当前结点
nextPosition=currPosition->
FreeNode（currPosition）;
currPosition=nextPosition;
//移动到下一结点
head=tail=NULL;
~LinkedList（）
ClearList（）;
LinkedList<
operator=（constLinkedList&
if（this==&
L）//不能将链表赋值给它自身
return*this;
return*this;
intLinkedList<
ListSize（）const
returnsize;
ListEmpty（）const
if（size==0）
return1;
else
return0;
Reset（intpos）
intstartPos;
//如果链表为空，返回
if（head==NULL）
//如果位置不合法，中止程序
if（pos<
0||pos>
size-1）
cerr<
Thepositionyousetiswrongoroutofrange!
endl;
//设置与遍历链表有关的成员
if（pos==0）
//将指针重新设置到表头
position=0;
//重新设置currPtr,prevPtr,和position
currPtr=head->
prevPtr=head;
startPos=1;
//移动指针直到position==pos
for（position=startPos;
position!
=pos;
position++）
//向前移动遍历指针
prevPtr=currPtr;
Next（）
if（currPtr!
=NULL）
prevPtr=currPtr;
currPtr=currPtr->
position++;
EndOfList（）const
if（currPtr==NULL）
else
CurrentPosition（）const
returnposition;
InsertFront（constT&
item）
//如果链表不空则调用Reset
if（head!
Reset（）;
InsertAt（item）;
//在表头插入
InsertRear（constT&
item）
*newNode;
prevPtr=tail;
newNode=GetNode（item）;
//创建新结点
if（head==NULL）//如果表空则插入在表头
head=tail=newNode;
tail->
InsertAfter（newNode）;
tail=newNode;
currPtr=tail;
position=size;
size++;
InsertAt（constT&
//两种情况:
插入在链表头或链表之中
if（prevPtr==NULL）
//插入在链表头，包括将结点插入到空表中
newNode=GetNode（item,head）;
//插入到链表之中.将结点置于prevPtr之后
newN
升级会员 