c++类和对象实验资料报告材料.docx

c++类和对象实验资料报告材料.docx

《c++类和对象实验资料报告材料.docx》由会员分享，可在线阅读，更多相关《c++类和对象实验资料报告材料.docx（32页珍藏版）》请在冰豆网上搜索。

c++类和对象实验资料报告材料

实验一类和对象

实验课程名：

面向对象程序设计（C++）

专业班级：

学号：

：

实验时间：

实验地点：

指导教师：

一、实验目的和要求

（1）理解类和对象的概念，掌握声明类和定义对象的方法。

（2）掌握构造函数和析构函数的实现方法。

（3）初步掌握使用类和对象编制C++程序。

（4）掌握对象数组、对象指针和string类的使用方法。

（5）掌握使用对象、对象指针和对象引用作为函数参数的方法。

（6）掌握类对象作为成员的使用方法。

（7）掌握静态数据成员和静态成员函数的使用方法。

（8）理解友元的概念和掌握友元的使用方法。

二、实验容

1．设计一个静态数组存储结构的顺序表类，要求编程实现如下任务：

建立一个线性表，首先依次输人数据元素1，2，3，…，10，然后删除数据元素6，最后依次显示当前线性表中的数据元素。

要求采用顺序表实现，假设该顺序表的数据元素个数在最坏情况下不会超过50个。

实验代码：

#include

usingnamespacestd;

constintMaxSize=100;//100只是示例性的数据，可根据实际问题具体定义

template//定义模板类SeqList

classSeqList

{

public:

SeqList（）{length=0;}//无参构造函数

SeqList（Ta[],intn）;//有参构造函数

~SeqList（）{}//析构函数为空

intLength（）{returnlength;}//求线性表的长度

TGet（inti）;//按位查找，取线性表的第i个元素

intLocate（Tx）;//按值查找，求线性表中值为x的元素序号

voidInsert（inti,Tx）;//在线性表中第i个位置插入值为x的元素

TDelete（inti）;//删除线性表的第i个元素

voidPrintList（）;//遍历线性表，按序号依次输出各元素

private:

Tdata[MaxSize];//存放数据元素的数组

intlength;//线性表的长度

};

template

SeqList:

:

SeqList（Ta[],intn）

{

inti;

if（n>MaxSize）throw"参数非法";

for（i=0;i

data[i]=a[i];

length=n;

}

template

TSeqList:

:

Get（inti）

{

if（i<1&&i>length）throw"查找位置非法";

elsereturndata[i-1];

}

template

intSeqList:

:

Locate（Tx）

{

inti;

for（i=0;i

if（data[i]==x）returni+1;//下标为i的元素等于x，返回其序号i+1

return0;//退出循环，说明查找失败

}

template

voidSeqList:

:

Insert（inti,Tx）

{

intj;

if（length>=MaxSize）throw"上溢";

if（i<1||i>length+1）throw"位置";

for（j=length;j>=i;j--）

data[j]=data[j-1];//注意第j个元素存在数组下标为j-1处

data[i-1]=x;

length++;

}

template

TSeqList:

:

Delete（inti）

{

Tx;

intj;

if（length==0）throw"下溢";

if（i<1||i>length）throw"位置";

x=data[i-1];

for（j=i;j

data[j-1]=data[j];//注意此处j已经是元素所在的数组下标

length--;

returnx;

}

template

voidSeqList:

:

PrintList（）

{

inti;

for（i=0;i

cout<

cout<

}

intmain（）

{

intm,n,t;

inta[10]={0,1,2,3,4,5,6,7,8,9};

SeqListseq（a,10）;

SeqList*p;

p=&seq;

cout<<"线性表的长度为：

"<Length（）<

p->PrintList（）;

cout<<"请输入要查找元素的位置:

"<

cin>>n;

cout<<"您所要找的元素为：

"<Get（n）<

cout<<"请输入要查找的元素值：

"<

cin>>n;

cout<<"该值所在的位置为：

"<Locate（n）<

cout<<"请分别输入插入位置与要插入的元素"<

cin>>n>>t;

p->Insert（n,t）;

p->PrintList（）;

cout<<"请输入要删除的元素所在的位置：

"<

cin>>n;

p->Delete（n）;

p->PrintList（）;

return0;

}

运行结果：

2．设计一个带头结点的单链表类，要求：

（1）生成一个整数线性表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。

（2）设计一个测试主函数，实际运行验证所设计单链表类的正确性。

实验代码：

#include

usingnamespacestd;

template

structNode

{

Tdata;

Node*next;//此处也可以省略

};

template

classLinkList

{

public:

LinkList（）{first=newNode;first->next=NULL;}//建立只有头结点的空链表

LinkList（Ta[],intn）;//建立有n个元素的单链表

~LinkList（）;//析构函数

intLength（）;//求单链表的长度

TGet（inti）;//取单链表中第i个结点的元素值

intLocate（Tx）;//求单链表中值为x的元素序号

voidInsert（inti,Tx）;//在单链表中第i个位置插入元素值为x的结点

TDelete（inti）;//在单链表中删除第i个结点

voidPrintList（）;//遍历单链表，按序号依次输出各元素

Node*first;//单链表的头指针

};

template

LinkList:

:

LinkList（Ta[],intn）//头查法建立单链表

{

inti;

Node*s;

first=newNode;

first->next=NULL;//初始化一个空链表

for（i=n-1;i>=0;i--）

{

s=newNode;s->data=a[i];//为每个数组元素建立一个结点

s->next=first->next;//插入到头结点之后

first->next=s;

}

}

template

LinkList:

:

~LinkList（）//析构函数

{

Node*p,*q;

p=first;

while（p）

{

q=p;

p=p->next;

deleteq;

}

}

template

intLinkList:

:

Length（）//求链表的长度

{

inti=0;

Node*p;

p=first;

while（p）

{

p=p->next;

i++;

}

returni-1;

}

template

TLinkList:

:

Get（inti）//求单链表中第i个元素的值

{

intn=0;

Node*p;

p=first;

while（p&&i>n）

{

p=p->next;

n++;

}

returnp->data;

}

template

intLinkList:

:

Locate（Tx）//求单链表中值为x的元素序号

{

inti;

Node*p;

p=first;

for（i=0;p;i++）

{

if（p->data==x）

returni;

p=p->next;

}

}

template

voidLinkList:

:

PrintList（）//输出函数

{

Node*p;

p=first->next;

while（p）

{

cout<data<<'';

p=p->next;

}

cout<

}

template

voidLinkList:

:

Insert（inti,Tx）//在第i个位置插入元素x

{

intn=0;

Node*p,*q;

p=first;

while（p&&n

{

p=p->next;

++n;

}

q=newNode;

q->data=x;

q->next=p->next;

p->next=q;

}

template

TLinkList:

:

Delete（inti）//删除第i个结点

{

intn=0;

Node*p,*q;

p=first;

while（p->next&&n

{

p=p->next;

++n;

}

q=p->next;

p->next=q->next;

returnq->data;

deleteq;

}

intmain（）

{

Node*p,*q,*r;

inta[10]={0,1,2,3,4,5,6,7,8,9};

LinkListL1（a,10）,L2,L3;//定义三个链表

cout<

p=L1.first->next,q=L2.first,r=L3.first;

L2.first=newNode;

L2.first->next=NULL;

L3.first=newNode;

L3.first->next=NULL;

while（p）//当链表L1中有元素时进行循环

{

if（p->data%2==0）//当L1中的元素为偶数时插入L2

{

q=newNode;

q->data=p->data;

q->next=L2.first->next;

L2.first->next=q;

}

else

{

r=newNode;

r->data=p->data;

r->next=L3.first->next;

L3.first->next=r;

}

p=p->next;

}

L1.PrintList（）;

L2.PrintList（）;

L3.PrintList（）;

cout<<"链表的长度为：

"<

cout<<"链表的第四个元素为：

"<

cout<<"链表中元素5为第"<

L1.Insert（4,17）;

cout<<"插入元素后链表为：

";

L1.PrintList（）;

L1.Delete（8）;

cout<<"删除第8个元素后链表变为：

";

L1.PrintList（）;

return0;

}

实验结果：

3．设计一个不带头结点的单链表类，要求：

（1）不带头结点单链表类的成员函数包括取数据元素个数、插入元素、删除所有值为k的元素、取数据元素。

（提示：

要考虑在第一个数据元素结点前插入和删除第一个数据元素结点时与在其他位置插入和删除其他位置结点时的不同情况。

）

（2）设计一个测试主函数，实际运行验证所设计循环单链表类的正确性。

实验代码：

#include

usingnamespacestd;

template

structNode

{

Tdata;

Node*next;

};

template

classLinkList

{

public:

LinkList（）{first=newNode;first->next=NULL;}//建立只有头结点的空链表

LinkList（Ta[],intn）;

~LinkList（）;

intLength（）;//求单链表的长度

TGet（inti）;//取单链表中第i个结点的元素值

voidInsert（inti,Tx）;//在单链表中第i个位置插入元素值为x的结点

TDelete（inti）;//在单链表中删除第i个结点

voidPrintList（）;//遍历单链表，按序号依次输出各元素

private:

Node*first;//单链表的头指针

};

template

LinkList:

:

LinkList（Ta[],intn）

{

inti=1;

Node*p,*q;

first=newNode;

first->data=a[0];

first->next=NULL;

p=first;

for（i=1;i

{

q=newNode;

q->data=a[i];

q->next=NULL;

p->next=q;

p=q;

}

}

template

LinkList:

:

~LinkList（）

{

Node*p;

p=first;

while（p）

{

p=p->next;

deletefirst;

first=p;

}

}

template

intLinkList:

:

Length（）

{

inti=0;

Node*p;

p=first;

while（p）

{

p=p->next;

i++;

}

returni;

}

template

TLinkList:

:

Get（inti）

{

intj=1;

Node*p;

p=first;

while（p&&j

{

p=p->next;

j++;

}

returnp->data;

}

template

voidLinkList:

:

Insert（inti,Tx）

{

intj=1;

Node*p,*q;

p=first;

while（p&&j

{

p=p->next;

j++;

}

q=newNode;

q->data=x;

q->next=p->next;

p->next=q;

}

template

TLinkList:

:

Delete（inti）

{

intj=1;

Node*p,*q;

p=first;

while（p&&j

{

p=p->next;

j++;

}

q=p->next;

p->next=q->next;

returnq->data;

deleteq;

}

template

voidLinkList:

:

PrintList（）

{

Node*p;

p=first;

while（p）

{

cout<data<<'';

p=p->next;

}

cout<

}

intmain（）

{

inta[10]={0,1,2,3,4,5,6,7,8,9};

LinkListL（a,10）;

cout<<"链表长为：

"<

cout<<"链表的第6个元素为：

"<

L.Insert（5,17）;

cout<<"在链表第5个位置插入元素17后链表变为：

";

L.PrintList（）;

L.Delete（8）;

cout<<"删除第8个元素后链表变为：

";

L.PrintList（）;

return0;

}

实验结果为：

4．设计一个带头结点的循环单链表类，实现约瑟夫环问题；

问题描述：

设编号为1,2,…，n（n>0）个人按顺时针方向围坐-圈，每人持有一个正整数密码。

开始时任意给出一个报数上限值m从第一个人开始顺时针方向自1起顺序报数。

报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人起重新自1起顺序报数.如此下去，直到所有人全部出列为止。

要求设计一个程序模拟此过程，并给出出列人的编号序列。

测试数据：

n=7,7个人的密码依次为3,1,7,2,4,8,4

初始报数上限值m=20

实验代码：

#include

usingnamespacestd;

structNode//定义一个接点包含编号，密码，指针变量

{

intnum;

intcode;

intdata;//标志位，当该人没有被踢出时为1

Node*next;

};

classCirList

{

public:

voidDone（）;//踢人，实现约瑟夫环的功能

CirList（）;//构造函数，建立一个带头结点的循环链表

voidinputcode（）;//输入密码

private:

Node*first;

intperson;//定义游戏人数

};

CirList:

:

CirList（）

{

inti;

Node*p;

first=newNode;

first->next=NULL;

cout<<"请输入游戏人数：

";

cin>>person;

for（i=person;i>0;i--）

{

p=newNode;

p->num=i;

p->data=1;

p->next=first->next;

first->next=p;

}

while（p->next）

{

p=p->next;

}

p->next=first;

}

voidCirList:

:

inputcode（）

{

Node*p;

inti;

p=first->next;

cout<<"请输入每个人的密码：

";

for（i=0;i

{

cin>>p->code;

p=p->next;

}

}

voidCirList:

:

Done（）

{

intm=20,n,i=1;

Node*p;

p=first;

p=p->next;

for（n=person;n>0;n--）

{

while（i!

=m）

{

p=p->next;

if（p->data==1）

{

i++;

}

}

cout<num<<'';

m=p->code;

p->data=0;

i=0;

}

cout<

}

intmain（）

{

CirListlist;

list.inputcode（）;

list.Done（）;

return0;

}

实验结果：

*5．设计一个带头结点的循环双向链表类，要求：

（1）带头结点循环双向链表类的成员函数包括：

取数据元素个数、插入、删除、取数据元素。

（2）设计一个测试主函数，实际运行验证所设计循环双向链表类的正确性

实验代码：

#include

usingnamespacestd;

template

structNode

{

Tdata;

Node*next,*front;

};

template

classLinkList

{

public:

LinkList（）{first=newNode;first->next=NULL;first->front=NULL;}//建立只有头结点的空链表

LinkList（Ta[],intn）;//建立有n个元素的双向链表

~LinkList（）;//析构函数

intLength（）;//求双向链表的长度

TGet（inti）;//取双向链表中第i个结点的元素值

intLocate（Tx）;//求双向链表中值为x的元素序号

voidInsert（inti,Tx）;//在双向链表中第i个位置插入元素值为x的结点

TDelete（inti）;//在双向链表中删除第i个结点

voidPrintList（）;//遍历单链表，按序号依次输出各元素

private:

Node*first;//双向链表的头指针

};

template

LinkList:

:

LinkList（Ta[],