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

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

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

面向对象程序设计课程实验报告

课程实验报告

课程名称：

面向对象程序设计

院系：

专业班级：

学号：

姓名：

指导教师：

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

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

elems[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;i

cout<

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栈的，当前元素也需一致