面向对象程序设计课程实验报告材料Word文件下载.docx
《面向对象程序设计课程实验报告材料Word文件下载.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计课程实验报告材料Word文件下载.docx（48页珍藏版）》请在冰豆网上搜索。
//出栈到e，并返回p
STACK*constassign（STACK*constp,constSTACK&
//赋给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个元素
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
e）
int&
e
出栈到e，并返回p
s）
STACK&
赋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<
stdio.h>
malloc.h>
stdlib.h>
structSTACK
{
//栈能存放的最大元素个数
//栈实际已有元素个数，栈空时pos=0;
//初始化p指向的栈：
最多m个元素
//用栈s初始化p指向的栈
//返回p指向的栈的最大元素个数max
//返回p指向的栈的实际元素个数pos
//出栈到e，并返回p
//赋s给p指的栈,并返回p
//打印p指向的栈
//销毁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）;
栈s2:
inta,b,c;
a=size（s1）;
栈的最大元素个数是%d\n"
a）;
b=howMany（s1）;
栈的实际元素个数是%d\n"
b）;
c=getelem（s1,3）;
3处栈元素是是%d\n"
c）;
intx,y,z;
pop（s2,x）;
pop（pop（s2,y）,z）;
x=%d,y=%d,z=%d\n"
x,y,z）;
destroySTACK（s2）;
destroySTACK（s1）;
getchar（）;
return0;
}
voidinitSTACK（STACK*constp,intm）//初始化p指向的栈：
p->
elems=（int*）malloc（m*sizeof（int*））;
if（!
p->
elems）
return;
pos=0;
max=m;
inti;
for（i=0;
i<
（p->
max）;
i++）
elems[i]=0;
s）//用栈s初始化p指向的栈
elems=（int*）malloc（（s.max）*sizeof（int））;
pos=s.pos;
max=s.max;
（s.pos）;
{
elems[i]=s.elems[i];
%d\n"
p->
elems[i]）;
}
intsize（constSTACK*constp）//返回p指向的栈的最大元素个数max
returnp->
max;
inthowMany（constSTACK*constp）//返回p指向的栈的实际元素个数pos
pos;
intgetelem（constSTACK*constp,intx）//取下标x处的栈元素
if（p==NULL）
returnNULL;
else
if（x>
pos））
不存在元素\n"
elems[x];
STACK*constpush（STACK*constp,inte）//将e入栈，并返回p
if（（p->
pos）<
=（p->
max））
elems[p->
pos]=e;
pos++;
returnp;
栈满\n"
e）//出栈到e，并返回p
pos）==0）
栈为空\n"
e=p->
elems[（p->
pos）-1];
（p->
pos）--;
s）//赋s给p指的栈,并返回p
if（p==NULL||&
s==NULL）
free（p->
elems）;
//free（p）;
//STACK*p=（STACK*）malloc（sizeof（STACK））;
initSTACK（p,s）;
voidprint（constSTACK*constp）//打印p指向的栈
if（p==NULL）
elseif（p->
pos==0）
pos）;
%d"
voiddestroySTACK（STACK*constp）//销毁p指向的栈
free（p）;
栈已销毁\n"
实验二.面向对象的整型栈编程
整型栈类型及其操作函数采用面向对象的C++语言定义，请将完成上述操作的所有函数采用C++编程，然后写一个main函数对栈的所有操作函数进行测试。
classSTACK{
int*constelems;
constintmax;
//栈实际已有元素个数，栈空时pos=0;
public:
STACK（intm）;
//初始化栈：
STACK（constSTACK&
//用栈s拷贝初始化栈
intsize（）const;
//返回栈的最大元素个数max
inthowMany（）const;
//返回栈的实际元素个数pos
intgetelem（intx）const;
push（inte）;
//将e入栈,并返回栈
pop（int&
//出栈到e,并返回栈
assign（constSTACK&
//赋s给栈,并返回被赋值的栈
voidprint（）const;
//打印栈
~STACK（）;
//销毁栈
采用面向对象的C++语言定义整型栈，对其进行的操作通常包括判断栈是否为空、向栈顶添加一个整型元素、出栈等。
首先需要定义一个类来实现栈，然后依次实现栈的各个功能，在主函数中给定一个栈然后，然后通过函数调用实现栈的功能。
STACK（intm）
初始化栈：
返回值：
用栈s拷贝初始化栈
intsize（）const
返回栈的最大元素个数max
最大元素个数max
inthowMany（）const
返回栈的实际元素个数pos
元素数目pos
intgetelem（intx）const
下标为x的元素
push（inte）
将e入栈
栈的引用
e）
出栈到e,并返回栈
使用栈s给栈p赋值
voidprint（）const
打印栈
~STACK（）
销毁栈
测试结果见图2.1
图2.1
完成了初定目标，无其他特点。
人机交互需要进一步完善。
由于第一次使用c++面向对象编写程序，开始不明白对象的生成及使用。
在和同学老师的沟通和交流中，慢慢学会了编程的方法。
C++语言与C语言有很多相通的地方，所以其中的某些原理和方法可以互相借鉴，这样就减少了在理解上的难度。
experiment2.cpp源码
experiment2.exe可执行文件。
experiment2.cpp是程序的源码，可通过修改其中main函数中的变量来测试各个函数。
#include<
iostream>
string>
usingnamespacestd;
STACK:
:
STACK（intm）:
elems（newint[m]）,max（m）,pos（0）{}
s）:
elems（newint[s.size（）]）,max（s.size（））,pos（s.howMany（））
for（inti=0;
elems[i]=s.getelem（i）;
cout<
<
"
复制构造成功"
endl;
intSTACK:
size（）const
returnmax;
howMany（）const
returnpos;
getelem（intx）const
returnelems[x];
STACK:
push（inte）
if（pos<
max）
elems[pos]=e;
pos++;
elsecout<
full\n"
;
return*this;
pop（int&
e）{
if（pos==0）
emptystack"
return*this;
pos--;
e=elems[pos];
出栈成功"
assign（constSTACK&
s）{
deleteelems;
//elems=newint[s.size（）];
//max=s.size（）;
pos=s.howMany（）;
s.howMany（）;
{elems[i]=s.getelem（i）;
voidSTACK:
print（）const{
栈的元素为：
elems[i]<
"
~STACK（）{
//elems=0;
//max=0;
pos=0;
析构完成"
intmain（）
STACKs（7）;
s.push（5）;
s.push（7）;
s.push（9）;
s.push（11）;
s.print（）;
s.pop（i）;
出栈元素"
STACKp（s）;
容量"
p.size（）<
当前元素数目"
p.howMany（）;
实验三.基于算符重载的整型栈编程
//用栈s拷贝初始化栈
virtualintsize（）const;
virtualoperatorint（）const;
virtualintoperator[]（intx）const;
//取下标x处的栈元素
virtualSTACK&
operator<
（inte）;
operator>
>
（int&
//出栈到e,并返回栈
operator=（constSTACK&
//赋s给栈,并返回被赋值的栈
virtualvoidprint（）const;
//打印栈
virtual~STACK（）;
//销毁栈
采用面向对象的C++语言定义，构建整型栈并对其进行判断栈是否为空、向栈顶添加一个整型元素、出栈等操作。
初始化定义一个类，分配一个数组空间来存储栈内元素信息，然后初始化为0；
实现入栈则需要将入栈元素e放入栈内，采用了先判断栈的最大容量够不够的问题，如果不够重新分配空间，并且让e入栈，将当前元素pos加一；
然后返回栈结构。
实现出栈操作，首先判断是不是空，若空直接返回，不空则需将栈顶的元素赋给一个变量然后将当前元素pos减一；
返回栈结构。
实现栈的赋给即需要将s1栈内的元素依次赋给s2栈的，当前元素也需
升级会员 