面向对象程序设计课程实验报告材料.docx
《面向对象程序设计课程实验报告材料.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计课程实验报告材料.docx（48页珍藏版）》请在冰豆网上搜索。
面向对象程序设计课程实验报告材料
课程实验报告
课程名称：
面向对象程序设计
院系：
专业班级：
学号：
姓名：
指导教师：
实验一.面向过程的整型栈编程
1.需求分析
1.1题目要求
整型栈是一种先进后出的存储结构，对其进行的操作通常包括判断栈是否为空、向栈顶添加一个整型元素、出栈等。
整型栈类型及其操作函数采用非面向对象的纯C语言定义，请将完成上述操作的所有函数采用面向过程的方法编程，然后写一个main函数对栈的所有操作函数进行测试。
structSTACK{
int*elems;//申请内存用于存放栈的元素
intmax;//栈能存放的最大元素个数
intpos;//栈实际已有元素个数，栈空时pos=0;
};
voidinitSTACK（STACK*constp,intm）;//初始化p指空栈：
可存m个元素
voidinitSTACK（STACK*constp,constSTACK&s）;//用s初始化p指空栈
intsize（constSTACK*constp）;//返回p指的栈的最大元素个数max
inthowMany（constSTACK*constp）;//返回p指的栈的实际元素个数pos
intgetelem（constSTACK*constp,intx）;//取下标x处的栈元素
STACK*constpush（STACK*constp,inte）;//将e入栈，并返回p
STACK*constpop（STACK*constp,int&e）;//出栈到e，并返回p
STACK*constassign（STACK*constp,constSTACK&s）;//赋给p指栈,返回p
voidprint（constSTACK*constp）;//打印p指向的栈元素
voiddestroySTACK（STACK*constp）;//销毁p指向的栈，释放
1.2需求分析
本实验需要实现栈的功能的操作，如元素的进栈，连续进栈，出栈和连续出栈，所以需要设计两个栈，在完成初始化后直接在程序里给定栈内元素。
2.系统设计
2.1概要设计
函数结构图见图1.1
图1.1
总体流程图见图1.2
图1.2
2.2详细设计
voidinitSTACK（STACK*constp,intm）
入口参数：
intm
出口参数：
无
功能：
初始化栈，可存m个元素
voidinitSTACK（STACK*constp,constSTACK&s）
入口参数：
constSTACK&s
出口参数：
无
功能：
用s初始化p指空栈
intsize（constSTACK*constp）
入口参数：
无
出口参数：
intmax
功能：
返回p指的栈的最大元素个数max
inthowMany（constSTACK*constp）
入口参数：
无
出口参数：
intpos
功能：
返回p指的栈的实际元素个数pos
intgetelem（constSTACK*constp,intx）
入口参数：
intx
出口参数：
elem[m]
功能：
取下标x处的栈元素
STACK*constpush（STACK*constp,inte）
入口参数：
inte
出口参数：
（*this）
功能：
将e入栈，并返回p
STACK*constpop（STACK*constp,int&e）
入口参数：
int&e
出口参数：
（*this）
功能：
出栈到e，并返回p
STACK*constassign（STACK*constp,constSTACK&s）
入口参数：
STACK&s
出口参数：
（*this）
功能：
赋s给p指栈,返回p
voidprint（constSTACK*constp）
入口参数：
无
出口参数：
无
功能：
打印p指向的栈元素
voiddestroySTACK（STACK*constp）
入口参数：
出口参数：
功能：
销毁p指向的栈，释放
3.软件开发
在Codeblocks编译环境下，使用C++语言编写。
4.软件测试
测试结果见图1.3
图1.3
5.特点与不足
5.1技术特点
完成了实验的所有要求，没有错误的地方。
5.2不足和改进的建议
没有做人机交互界面，无法自由选择入栈的数据；同时注释较少，对于程序不了解的人可能需要花费更多时间去了解。
6.过程和体会
6.1遇到的主要问题和解决方法
输出结果数字与预计不同，检查后发现原因是变量初始值未设置。
6.2课程设计的体会
本次实验主要还是通过回顾C语言中栈的知识完成在C++上的编程，所以总体过程没有出现太大的问题；同时也对const变量有了进一步的认识。
7.源码和说明
7.1文件清单及其功能说明
experiment1.cpp源码
experiment1.exe可执行文件。
7.2用户使用说明书
experiment1.cpp是程序的源码，可通过修改其中main函数中的变量来测试各个函数。
7.3源代码
#include
#include
#include
structSTACK
{
int*elems;//申请内存用于存放栈的元素
intmax;//栈能存放的最大元素个数
intpos;//栈实际已有元素个数，栈空时pos=0;
};
voidinitSTACK（STACK*constp,intm）;//初始化p指向的栈：
最多m个元素
voidinitSTACK（STACK*constp,constSTACK&s）;//用栈s初始化p指向的栈
intsize（constSTACK*constp）;//返回p指向的栈的最大元素个数max
inthowMany（constSTACK*constp）;//返回p指向的栈的实际元素个数pos
intgetelem（constSTACK*constp,intx）;//取下标x处的栈元素
STACK*constpush（STACK*constp,inte）;//将e入栈，并返回p
STACK*constpop（STACK*constp,int&e）;//出栈到e，并返回p
STACK*constassign（STACK*constp,constSTACK&s）;//赋s给p指的栈,并返回p
voidprint（constSTACK*constp）;//打印p指向的栈
voiddestroySTACK（STACK*constp）;//销毁p指向的栈
intmain（intargc,char*argv[]）
{
STACK*s1=（STACK*）malloc（sizeof（STACK））;
STACK*s2=（STACK*）malloc（sizeof（STACK））;
initSTACK（s1,10）;
push（s1,1）;
push（s1,2）;
push（push（s1,3）,4）;
initSTACK（s2,*s1）;
print（s2）;
printf（"栈s1:
\n"）;
print（s1）;
//assign（s2,*s1）;
printf（"栈s2:
\n"）;
print（s2）;
inta,b,c;
a=size（s1）;
printf（"栈的最大元素个数是%d\n",a）;
b=howMany（s1）;
printf（"栈的实际元素个数是%d\n",b）;
c=getelem（s1,3）;
printf（"3处栈元素是是%d\n",c）;
intx,y,z;
pop（s2,x）;
pop（pop（s2,y）,z）;
printf（"x=%d,y=%d,z=%d\n",x,y,z）;
destroySTACK（s2）;
destroySTACK（s1）;
getchar（）;
return0;
}
voidinitSTACK（STACK*constp,intm）//初始化p指向的栈：
最多m个元素
{
p->elems=（int*）malloc（m*sizeof（int*））;
if（!
p->elems）
return;
p->pos=0;
p->max=m;
inti;
for（i=0;i<（p->max）;i++）
p->elems[i]=0;
}
voidinitSTACK（STACK*constp,constSTACK&s）//用栈s初始化p指向的栈
{
p->elems=（int*）malloc（（s.max）*sizeof（int））;
p->pos=s.pos;
p->max=s.max;
inti;
for（i=0;i<（s.pos）;i++）
{
p->elems[i]=s.elems[i];
printf（"%d\n",p->elems[i]）;
}
}
intsize（constSTACK*constp）//返回p指向的栈的最大元素个数max
{
returnp->max;
}
inthowMany（constSTACK*constp）//返回p指向的栈的实际元素个数pos
{
returnp->pos;
}
intgetelem（constSTACK*constp,intx）//取下标x处的栈元素
{
if（p==NULL）
returnNULL;
else
{
if（x>（p->pos））
printf（"不存在元素\n"）;
else
returnp->elems[x];
}
}
STACK*constpush（STACK*constp,inte）//将e入栈，并返回p
{
if（p==NULL）
returnNULL;
else
{
if（（p->pos）<=（p->max））
{
p->elems[p->pos]=e;
p->pos++;
returnp;
}
else
printf（"栈满\n"）;
}
}
STACK*constpop（STACK*constp,int&e）//出栈到e，并返回p
{
if（p==NULL）
returnNULL;
else
{
if（（p->pos）==0）
printf（"栈为空\n"）;
else
{
e=p->elems[（p->pos）-1];
（p->pos）--;
returnp;
}
}
}
STACK*constassign（STACK*constp,constSTACK&s）//赋s给p指的栈,并返回p
{
if（p==NULL||&s==NULL）
{
returnNULL;
}
else
{
free（p->elems）;
//free（p）;
//STACK*p=（STACK*）malloc（sizeof（STACK））;
initSTACK（p,s）;
returnp;
}
}
voidprint（constSTACK*constp）//打印p指向的栈
{
inti;
if（p==NULL）
{
return;
}
elseif（p->pos==0）
{
printf（"栈为空\n"）;
}
else
{
for（i=0;i<（p->pos）;i++）
{
printf（"%d",p->elems[i]）;
}
printf（"\n"）;
}
}
voiddestroySTACK（STACK*constp）//销毁p指向的栈
{
free（p->elems）;
free（p）;
printf（"栈已销毁\n"）;
}
实验二.面向对象的整型栈编程
1.需求分析
1.1题目要求
整型栈是一种先进后出的存储结构，对其进行的操作通常包括判断栈是否为空、向栈顶添加一个整型元素、出栈等。
整型栈类型及其操作函数采用面向对象的C++语言定义，请将完成上述操作的所有函数采用C++编程，然后写一个main函数对栈的所有操作函数进行测试。
classSTACK{
int*constelems;//申请内存用于存放栈的元素
constintmax;//栈能存放的最大元素个数
intpos;//栈实际已有元素个数，栈空时pos=0;
public:
STACK（intm）;//初始化栈：
最多m个元素
STACK（constSTACK&s）;//用栈s拷贝初始化栈
intsize（）const;//返回栈的最大元素个数max
inthowMany（）const;//返回栈的实际元素个数pos
intgetelem（intx）const;//取下标x处的栈元素
STACK&push（inte）;//将e入栈,并返回栈
STACK&pop（int&e）;//出栈到e,并返回栈
STACK&assign（constSTACK&s）;//赋s给栈,并返回被赋值的栈
voidprint（）const;//打印栈
~STACK（）;//销毁栈
};
1.2需求分析
采用面向对象的C++语言定义整型栈，对其进行的操作通常包括判断栈是否为空、向栈顶添加一个整型元素、出栈等。
2.系统设计
2.1概要设计
首先需要定义一个类来实现栈，然后依次实现栈的各个功能，在主函数中给定一个栈然后，然后通过函数调用实现栈的功能。
2.2详细设计
STACK（intm）
功能：
初始化栈：
最多m个元素
返回值：
无
STACK（constSTACK&s）
功能：
用栈s拷贝初始化栈
返回值：
无
intsize（）const
功能：
返回栈的最大元素个数max
返回值：
最大元素个数max
inthowMany（）const
功能：
返回栈的实际元素个数pos
返回值：
元素数目pos
intgetelem（intx）const
功能：
取下标x处的栈元素
返回值：
下标为x的元素
STACK&push（inte）
功能：
将e入栈
返回值：
栈的引用
STACK&pop（int&e）
功能：
出栈到e,并返回栈
返回值：
栈的引用
STACK&assign（constSTACK&s）
功能：
使用栈s给栈p赋值
返回值：
栈的引用
voidprint（）const
功能：
打印栈
返回值：
无
~STACK（）
功能：
销毁栈
返回值：
无
3.软件开发
在Codeblocks编译环境下，使用C++语言编写。
4.软件测试
测试结果见图2.1
图2.1
5.特点与不足
5.1技术特点
完成了初定目标，无其他特点。
5.2不足和改进的建议
人机交互需要进一步完善。
6.过程和体会
6.1遇到的主要问题和解决方法
由于第一次使用c++面向对象编写程序，开始不明白对象的生成及使用。
在和同学老师的沟通和交流中，慢慢学会了编程的方法。
6.2课程设计的体会
C++语言与C语言有很多相通的地方，所以其中的某些原理和方法可以互相借鉴，这样就减少了在理解上的难度。
7.源码和说明
7.1文件清单及其功能说明
experiment2.cpp源码
experiment2.exe可执行文件。
7.2用户使用说明书
experiment2.cpp是程序的源码，可通过修改其中main函数中的变量来测试各个函数。
7.3源代码
#include
#include
usingnamespacestd;
classSTACK{
int*constelems;//申请内存用于存放栈的元素
constintmax;//栈能存放的最大元素个数
intpos;//栈实际已有元素个数，栈空时pos=0;
public:
STACK（intm）;//初始化栈：
最多m个元素
STACK（constSTACK&s）;//用栈s拷贝初始化栈
intsize（）const;//返回栈的最大元素个数max
inthowMany（）const;//返回栈的实际元素个数pos
intgetelem（intx）const;//取下标x处的栈元素
STACK&push（inte）;//将e入栈,并返回栈
STACK&pop（int&e）;//出栈到e,并返回栈
STACK&assign（constSTACK&s）;//赋s给栈,并返回被赋值的栈
voidprint（）const;//打印栈
~STACK（）;//销毁栈
};
STACK:
:
STACK（intm）:
elems（newint[m]）,max（m）,pos（0）{}
STACK:
:
STACK（constSTACK&s）:
elems（newint[s.size（）]）,max（s.size（））,pos（s.howMany（））
{
for（inti=0;ielems[i]=s.getelem（i）;
cout<<"复制构造成功"<};
intSTACK:
:
size（）const
{
returnmax;
}
intSTACK:
:
howMany（）const
{
returnpos;
}
intSTACK:
:
getelem（intx）const
{
returnelems[x];
}
STACK&STACK:
:
push（inte）
{
if（pos{
elems[pos]=e;
pos++;
}
elsecout<<"full\n";
return*this;
}
STACK&STACK:
:
pop（int&e）{
if（pos==0）
{
cout<<"emptystack";return*this;
}
pos--;
e=elems[pos];
cout<<"出栈成功";
return*this;
}
STACK&STACK:
:
assign（constSTACK&s）{
inti;
deleteelems;
//elems=newint[s.size（）];
//max=s.size（）;
pos=s.howMany（）;
for（i=0;i{elems[i]=s.getelem（i）;}
return*this;
}
voidSTACK:
:
print（）const{
inti;
cout<<"栈的元素为：
";
for（i=0;icout<cout<}
STACK:
:
~STACK（）{
deleteelems;
//elems=0;
//max=0;
pos=0;
cout<<"析构完成";
}
intmain（）
{
STACKs（7）;
s.push（5）;
s.push（7）;
s.push（9）;
s.push（11）;
s.print（）;
inti;
s.pop（i）;
cout<<"出栈元素"<STACKp（s）;
cout<<"容量"<cout<<"当前元素数目"<}
实验三.基于算符重载的整型栈编程
1.需求分析
1.1题目要求
整型栈是一种先进后出的存储结构，对其进行的操作通常包括判断栈是否为空、向栈顶添加一个整型元素、出栈等。
整型栈类型及其操作函数采用面向对象的C++语言定义，请将完成上述操作的所有函数采用C++编程，然后写一个main函数对栈的所有操作函数进行测试。
classSTACK{
int*constelems;//申请内存用于存放栈的元素
constintmax;//栈能存放的最大元素个数
intpos;//栈实际已有元素个数，栈空时pos=0;
public:
STACK（intm）;//初始化栈：
最多m个元素
STACK（constSTACK&s）;//用栈s拷贝初始化栈
virtualintsize（）const;//返回栈的最大元素个数max
virtualoperatorint（）const;//返回栈的实际元素个数pos
virtualintoperator[]（intx）const;//取下标x处的栈元素
virtualSTACK&operator<<（inte）;//将e入栈,并返回栈
virtualSTACK&operator>>（int&e）;//出栈到e,并返回栈
virtualSTACK&operator=（constSTACK&s）;//赋s给栈,并返回被赋值的栈
virtualvoidprint（）const;//打印栈
virtual~STACK（）;//销毁栈
};
1.2需求分析
采用面向对象的C++语言定义，构建整型栈并对其进行判断栈是否为空、向栈顶添加一个整型元素、出栈等操作。
2.系统设计
2.1概要设计
首先需要定义一个类来实现栈，然后依次实现栈的各个功能，在主函数中给定一个栈然后，然后通过函数调用实现栈的功能。
2.2详细设计
初始化定义一个类，分配一个数组空间来存储栈内元素信息，然后初始化为0；
实现入栈则需要将入栈元素e放入栈内，采用了先判断栈的最大容量够不够的问题，如果不够重新分配空间，并且让e入栈，将当前元素pos加一；然后返回栈结构。
实现出栈操作，首先判断是不是空，若空直接返回，不空则需将栈顶的元素赋给一个变量然后将当前元素pos减一；返回栈结构。
实现栈的赋给即需要将s1栈内的元素依次赋给s2栈的，当前元素也需
升级会员 