面向对象程序设计课程实验报告Word格式.docx

面向对象程序设计课程实验报告Word格式.docx

《面向对象程序设计课程实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计课程实验报告Word格式.docx（42页珍藏版）》请在冰豆网上搜索。

实验三.基于算符重载的整型栈编程19

1.需求分析19

1.1题目要求19

1.2需求分析19

2.系统设计20

2.1概要设计20

2.2详细设计20

3.软件开发20

4.软件测试20

5.特点与不足21

5.1技术特点21

5.2不足和改进的建议21

6.过程和体会21

6.1遇到的主要问题和解决方法21

6.2课程设计的体会21

7.源码和说明21

7.1文件清单及其功能说明21

7.2用户使用说明书21

7.3源代码21

实验四.面向对象的整型队列编程25

1.需求分析25

1.1题目要求25

1.2需求分析25

2.系统设计26

3.软件开发26

4.软件测试26

5.特点与不足26

5.1技术特点26

5.2不足和改进的建议26

6.过程和体会26

6.1遇到的主要问题和解决方法26

6.2课程设计的体会27

7.源码和说明27

7.1文件清单及其功能说明27

7.2用户使用说明书27

7.3源代码27

实验五.基于组合的整型队列编程31

1.需求分析31

1.1题目要求31

1.2需求分析31

2.系统设计31

3.软件开发32

4.软件测试32

5.特点与不足32

5.1技术特点32

5.2不足和改进的建议32

6.过程和体会32

6.1遇到的主要问题和解决方法32

6.2课程设计的体会32

7.源码和说明33

7.1文件清单及其功能说明33

7.2用户使用说明书33

7.3源代码33

实验六.基于继承的整型队列编程37

1.需求分析37

1.1题目要求37

1.2需求分析38

2.系统设计38

3.软件开发38

4.软件测试38

5.特点与不足38

5.1技术特点38

5.2不足和改进的建议38

6.过程和体会39

6.1遇到的主要问题和解决方法39

6.2课程设计的体会39

7.源码和说明39

7.1文件清单及其功能说明39

7.2用户使用说明书39

7.3源代码39

实验一.面向过程的整型栈编程

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&

//赋给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

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

//赋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（!

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];

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指向的栈

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,并返回栈

使用栈s给栈p赋值

voidprint（）const

打印栈

~STACK（）

销毁栈

测试结果见图2.1

图2.1

完成了初定目标，无其他特点。

人机交互需要进一步完善。

由于第一次使用c++面向对象编写程序，开始不明白对象的生成及使用。

在和同学老师的沟通和交流中，慢慢学会了编程的方法。

C++语言与C语言有很多相通的地方，所以其中的某些原理和方法可以互相借鉴，这样就减少了在理解上的难度。

experiment2.cpp源码

experiment2.exe可执行文件。

experiment2.cpp是程序的源码，可通过修改其中main函数中的变量来测试各个函数。

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];

if（pos<

max）

elems[pos]=e;

elsecout<

full\n"

;

return*this;

e）{

if（pos==0）

emptystack"

pos--;

e=elems[pos];

出栈成功"

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;

析构完成"

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（）;

实验三.基于算符重载的整型栈编程

//用栈