C++综合实验四.docx

C++综合实验四.docx

《C++综合实验四.docx》由会员分享，可在线阅读，更多相关《C++综合实验四.docx（36页珍藏版）》请在冰豆网上搜索。

C++综合实验四

《程序设计语言》实验报告

实验序号：

　04　　　　　　　实验项目名称：

面向对象的程序设计

学　　号

姓　　名

专业、班

实验地点

文波楼219

指导教师

时间

2012/12/19

一、实验目的及要求

1.掌握类和对象的定义

2.掌握面向对象的程序设计方法

3.掌握类的继承与派生

4.掌握基类和虚函数的用法

5.掌握运算符重载的方法

6.掌握I/O流类的操作

二、实验设备（环境）及要求

1.软件需求:

VisualC++

2.硬件需求:

PentiumIII450以上的CPU处理器，64MB以上的内存，200MB的自由硬盘空间

三、实验内容与步骤

1.设计员工类Employee（静态数据成员）分

a）题目描述

b）定义一个描述员工（Employee）基本情况的类，数据成员包括编号（num）、姓名（name）、性别（sex）、工资（wage）、人数（count）、总工资（totalWage）。

其中姓名定义为长度为18的字符数组，性别定义为长度为3的字符数组，其它数据类型为整型，总工资和人数为静态数据成员，函数成员包括构造函数、显示基本函数（ShowBase）和显示静态数据函数（ShowStatic），其中构造函数由已知参数编号（nu），姓名（nm）、性别（sx）和工资（wg）构造对象，显示基本数据函数用于显示学生的编号、姓名、性别和工资，显示静态数据函数为静态成员函数，用于显示人数和总工资；要求所有数据成员为protected访问权限，所有成员函数为public访问权限，在主函数中定义若干个员工对象，分别显示员工基本信息，以及显示员工人数和总工资。

c）输入描述

d）第一行要求输入一个小于10的数字n，表示即将录入的员工数量，换行后从键盘录入每个员工的数据，依次是编号，姓名，性别，工资，每个员工占一行

e）输出描述

f）第一行显示“人数：

”，第二行显示“总工资：

”，后面分别显示每个员工的信息，每个员工之间空一行

g）样例输入

h）2

i）1008张三男2500

j）1009李四女2600

k）样例输出

人数：

2

总工资：

5100元

个人基本信息：

编号：

1008

姓名：

张三

性别：

男

工资：

2500

个人基本信息：

编号：

1009

姓名：

李四

性别：

女

工资：

2600

2.日期类Date的设计（构造函数） 

a）题目描述

b）定义一个日期类Date，能提供和设置由年、月、日组成的日期。

编写程序，提供类的构造函数用于根据输入初始化日期类Date的对象；提供函数用于输出日期类对象的日期，按照如下格式输出：

yyyy-mm-dd

c）输入描述

d）初始化日期类Date对象的数据，分别是年、月、日。

程序有多个测试用例。

e）输出描述

f）按照指定格式输出的日期。

g）样例输入

20101230

20121830

2012610

h）样例输出

2010-12-30

ERRORDATE

2012-06-10

3.复数类Imaginary（友元函数）

a）题目描述

b）根据以下主函数的功能来设计复数类Imaginary，使其能正确运行。

类Imaginary中应该具有描述复数的实部和虚部的私有数据成员a和b，还有相应的构造函数和按照“a±bi”格式显示复数的成员函数print（）。

设计类Imaginary的2个友元函数分别进行复数的加、减运算，并在这些函数调用类Imaginary的成员函数print（）显示结果。

intmain（）

{

floatx1,y1,x2,y2;

c）cin>>x1>>y1>>x2>>y2;

d）样例输入

3

Rect0024

Circle003

Triangle002220

e）样例输出

4.简单高精度计算

a）题目描述

b）整型是经常使用的数据类型，常用的32位整数表示精度不超过10位十进制整数。

在很多运算中往往需要更高的精度，这时就必须自己编程突破系统已经定义数据类型的限制。

c）一个可行的方法是采用一个数组表示一个大的整数，每一个数组元素表示这个大整数的一位。

例如定义一个数组a[30]，其各个元素分别为：

9，8，7，6，5，4，3，2，1，0，9，8，7，6，5，4，3，2，1，0，9，8，7，6，5，4，3，2，1，0，则可以用来表示30位十进制整数0。

d）请你编写程序（不考虑负数）：

i.定义一个非负整数类BigInteger，在类中使用动态分配存储空间来存放整数的各个数位，并实现非负大整数的

1.初始化、复制、赋值、输入、显示；

2.关系运算

3.加法、减法（求两个操作数之差的绝对值，结果非负）、乘法运算；

ii.编写主程序利用非负整数类BigInteger完成各类运算，并输出结果

e）输入描述

f）输入有多组样例，每组样例由三行组成，第一行为操作数a，第二行为运算符op，第三行为操作数b。

其中a，b均为位数少于1000位的非负整数，op为下列运算之一：

+、-、*、==、!

=、>、>=、<、<=（其中减法定义为求两个操作数之差的绝对值）

g）输出描述

h）计算aopb的结果（算术运算的结果少于1000位），针对每组输入样例输出一行。

输出的算术运算结果要符合一般的数学表示习惯（例如，最高有效位的左边不能有前导的’0’），输出的关系运算结果以1表示真，0表示假。

i）样例输入

8450

+

78671

-

9578

700031

*

005

47824

==

2326

0167682

!

=

221

09

>

061173

28739

>=

4038774

03762

<

92

8570

<=

0

j）样例输出

1

27

6966444

0

1

0

1

1

0

四、实验结果与数据处理

第一题

2012-12-13howBase（）;

return0;

delete[]m;

}

第二题

//文件名：

cc

//功能：

日期类Date的设计（构造函数） 

//完成时间：

2012-12-13

#include

#include

usingnamespacestd;

classdate

{

protected:

inty,m,d;

staticintx;

public:

date（inty,intm,intd）;

date（）{};

~date（）{};

voiddisplay（inty,intm,intd）;

staticintgetx（）;

};

intdate:

:

x=1;

intdate:

:

getx（）

{

returnx;

}

voiddate:

:

display（inty,intm,intd）

{

cout<

（2）<

（2）<

}

date:

:

date（inty,intm,intd）

{

if（m>12）

{cout<<"ERRORDATE"<

if（m==1||m==3||m==5||m==7||m==8||m==10||m==12）

{

if（d>31）

{cout<<"ERRORDATE"<

}

if（m==2）

{

if（y%4==0&&y%100!

=0||y%400==0）

{

if（d>29）

{cout<<"ERRORDATE"<

}

else

{

if（d>28）

{cout<<"ERRORDATE"<

}

}

if（m==4||m==6||m==9||m==11）

{

if（d>30）

{cout<<"ERRORDATE"<

}

}

intmain（）

{

inty,m,d;

intk;

cin>>y>>m>>d;

dateA;

date（y,m,d）;

k=（）;

if（k）

（y,m,d）;

return0;

}

第三题

//文件名：

g4

//功能：

复数类Imaginary（友元函数）

//完成时间：

2012-12-14

#include

usingnamespacestd;

classImaginary

{

private:

floata,b;

public:

Imaginary（）{a=0,b=0;}

Imaginary（floati,floatj）;

~Imaginary（）;

friendImaginaryAdd（Imaginary&A,Imaginary&B）;

friendImaginarySub（Imaginary&A,Imaginary&B）;

voidprint（）

{

if（a==0）

{

if（b==0）

cout<

else

cout<

}

if（a）

{

cout<

if（b>0）

cout<<"+"<

else

if（b==0）

cout<

else

cout<

}

}

};

ImaginaryAdd（Imaginary&A,Imaginary&B）

{

floatm=+;

floatn=+;

ImaginaryC（m,n）;

（）;

returnC;

}

ImaginarySub（Imaginary&A,Imaginary&B）

{

floatm=floatn=ImaginaryD（m,n）;

（）;

returnD;

}

Imaginary:

:

Imaginary（floati,floatj）

{

a=i;b=j;

}

Imaginary:

:

~Imaginary（）{}

intmain（）

{

floatx1,y1,x2,y2;

cin>>x1>>y1>>x2>>y2;

Imaginaryimag1（x1,y1）,imag2（x2,y2）;

Add（imag1,imag2）;

Sub（imag1,imag2）;

return0;

}

第四题

//文件名：

g4

//功能：

二进制类

（1）——运算符重载

//完成时间：

2012-12-14

#include<>

#include<>

classbinary

{//定义二进制类

charbits[16];//二进制字模数组

public:

binary（char*）;//字符串参数构造函数

binary（int）;//整型参数构造函数

friendbinaryoperator+（binary&,binary&）;//重载"+"

friendbinaryoperator-（binary&,binary&）;//重载"-"

operatorint（）;//类类型转换函数

voidprint（）;

};

binary:

:

binary（char*a）

{

intm=strlen（a）-1;

intn=15;

while（m>=0&&n>=0）

bits[n--]=a[m--];

while（n>=0）

bits[n--]='0';

}

binary:

:

binary（inta）

{

for（inti=15;i>=0;i--）

{

bits[i]=a%2+'0';

a=a/2;

}

}

binaryoperator+（binary&a,binary&b）

{

binaryc（"00"）;

ints=0,n1=0,n2=0;

for（inti=0;i<16;i++）

n1=[i]=='0'0:

1）+n1*2;

for（i=0;i<16;i++）

n2=[i]=='0'0:

1）+n2*2;

s=n1+n2;

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

{

[i]=s%2+'0';

s=s/2;

}

returnc;

}

binaryoperator-（binary&a,binary&b）

{

binaryc（"00"）;

ints=0,n1=0,n2=0;

for（inti=0;i<16;i++）

n1=[i]=='0'0:

1）+n1*2;

for（i=0;i<16;i++）

n2=[i]=='0'0:

1）+n2*2;

s=n1-n2;

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

{

[i]=s%2+'0';

s=s/2;

}

returnc;

}

binary:

:

operatorint（）

{

ints=0;

for（inti=0;i<16;i++）

s=（bits[i]=='0'0:

1）+s*2;

returns;

}

voidbinary:

:

print（）

{

charstr[17];

strncpy（str,bits,16）;

str[16]='\0';

cout<

}

voidmain（）

{

binaryn1="1011";

binaryn2=int（n1）+15;

binaryn3=n1-binary（7）;

（）;

（）;

（）;

cout<

cout<

cout<

cout<

}

第五题

//文件名：

g4

//功能：

二进制类

（2）——运算符重载

//完成时间：

2012-12-18

#include<>

#include<>

classbinary

{//定义二进制类

charbits[16];//二进制字模数组

public:

binary（char*）;//字符串参数构造函数

binary（int）;//整型参数构造函数

friendbinaryoperator+（binary&,binary&）;//重载"+"

friendbinaryoperator-（binary&,binary&）;//重载"-"

friendbinaryoperator~（binary&）;

friendbinaryoperator&（binary&,binary&）;

friendbinaryoperator|（binary&,binary&）;

operatorint（）;//类类型转换函数

voidprint（）;

};

binary:

:

binary（char*a）

{

intm=strlen（a）-1;

intn=15;

while（m>=0&&n>=0）

bits[n--]=a[m--];

while（n>=0）

bits[n--]='0';

}

binary:

:

binary（inta）

{

for（inti=15;i>=0;i--）

{

bits[i]=a%2+'0';

a=a/2;

}

}

binaryoperator+（binary&a,binary&b）

{

binaryc="00";

intn1=0,n2=0,s=0;

for（inti=0;i<16;i++）

n1=[i]=='0'0:

1）+2*n1;

for（i=0;i<16;i++）

n2=[i]=='0'0:

1）+2*n2;

s=n1+n2;

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

{

[i]=s%2+'0';

s=s/2;

}

returnc;

}

binaryoperator-（binary&a,binary&b）

{

binaryc="00";

intn1=0,n2=0,s=0;

for（inti=0;i<16;i++）

n1=[i]=='0'0:

1）+2*n1;

for（i=0;i<16;i++）

n2=[i]=='0'0:

1）+2*n2;

s=n1-n2;

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

{

[i]=s%2+'0';

s=s/2;

}

returnc;

}

binaryoperator~（binary&a）

{

binaryc="00";

for（inti=0;i<16;i++）

{

if[i]=='0'）

[i]='1';

else

[i]='0';

}

returnc;

}

binaryoperator&（binary&a,binary&b）

{

binaryc="00";

for（inti=0;i<16;i++）

{

if（[i]=='1'）&&[i]=='1'））

[i]='1';

else

[i]='0';

}

returnc;

}

binaryoperator|（binary&a,binary&b）

{

binaryc="00";

for（inti=0;i<16;i++）

{

if（[i]=='1'）||[i]=='1'））

[i]='1';

else

[i]='0';

}

returnc;

}

binary:

:

operatorint（）

{

ints=0;

for（inti=0;i<16;i++）

s=（bits[i]=='0'0:

1）+2*s;

returns;

}

voidbinary:

:

print（）

{

charstr[17];

strncpy（str,bits,16）;

str[16]='\0';

cout<

}

voidmain（）

{

binaryn1="1011";

binaryn2=int（n1）+15;

binaryn3=n1-binary（7）;

（）;

（）;

（）;

binaryn4=n1&n2;

binaryn5=n1|n2;

binaryn6=~n1;

（）;

（）;

（）;

}

第六题

//文件名：

g4

//功能：

简单集合运算

//完成时间：

2012-12-19

#include

usingnamespacestd;

classcollect

{

intstr[100];

intnum;

public:

collect（）{}

collect（int*,int）;

paixu（）;

collectcollect:

:

operator+（collect&）;

collectcollect:

:

operator-（collect&）;

collectcollect:

:

operator/（collect&）;

add（int）;

inquire（int）;

del（int）;

voidprint（）;

};

collect:

:

add（intn）

{

for（inti=0;i

{

if（n

{

for（intj=num;j>i;j--）

str[j]=str[j-1];

str[j]=n;

break;

}

}

num++;

}

collect:

:

inquire（intn）

{

cout<

}

collect:

:

del（intn）

{

for（inti=n-1;i

str[i]=str[i+1];

num--;

}

collect:

:

collect（int*p,intn）

{

num=n;

for（inti=0;i

str[i]=p[i];

str[i]='\0';

}

collect:

:

paixu（）

{

inttemp=0;

for（inti=0;i

{

for（intj=0;j

{

if（str[j]>str[j+1]）

{

temp=str[j];

str[j]=str[j+1];

str[j+1]=temp;

}

}

}

}

collectcollect:

:

operator+（collect&A）

{

collectC;

inti,j,k=0,flag;

for（i=0;i<;i++,k++）

[k]=[i];

for（i=0;i

{

flag=1;

for（j=0;j<;j++）

if[j]==str[i]）

flag=0;

if（flag）

[k++]=str[i];

}

=k;

returnC;

}

collectcollect:

:

operator-（collect&A）

{

collectC;

inti,j,k=0;

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

{

for（j=0;j

if[i]==str[j]）

[k++]=[i];

}

=k;

returnC;

}

collectcollect:

:

operator/（collect&A）

{

collectC;

inti,j,k=0,flag;

for（i=0;i

{

flag=1;

for（j=0;j<;j++）

if[j]==str[i]）

flag=0;