面B实验程序完整版.docx

面B实验程序完整版.docx

《面B实验程序完整版.docx》由会员分享，可在线阅读，更多相关《面B实验程序完整版.docx（19页珍藏版）》请在冰豆网上搜索。

面B实验程序完整版

第一次实验

四．实验源程序及实验结果

#include

#include

usingnamespacestd;

classCTeacher;

classCStudent//学生类

{public:

CStudent（int,string,double）;

friendvoidDisplay（CStudent&）;//定义友元函数

friendCTeacher;//定义友元类

private:

intID;//学号

stringName;//姓名

doubleScore;//成绩

};

CStudent:

:

CStudent（inta1,stringa2,doublea3）:

ID（a1）,Name（a2）,Score（a3）{}//构造函数初始化数据成员

voidDisplay（CStudent&a）//输出姓名、成绩、等级

{intd;

d=a.Score/10;

cout<

switch（d）

{

case10:

case9:

cout<<"优秀"<

case8:

cout<<"良好"<

case7:

cout<<"中等"<

case6:

cout<<"及格"<

default:

cout<<"不及格"<

}

}

classCTeacher//定义教师类

{

public:

voidModify（CStudent&）;

voidDisplays（CStudent&）;

};

voidCTeacher:

:

Modify（CStudent&b）//修改成绩

{

doublechengji;

cout<<"输入分数：

";

cin>>chengji;

b.Score=chengji;

cout<<"修改成功!

"<

}

voidCTeacher:

:

Displays（CStudent&c）//输出需要查找的学生信息

{

Display（c）;

}

intmain（）

{cout<<"学号"<<"\t"<<"姓名"<<"\t"<<"\t"<<"成绩"<<"\t"<<"等级"<

cout<<"-------------------------------------"<

CStudentt1（1,"LeBronJames",75）;//定义一个学生类的对象

CStudentt2（2,"MichealJordan",98）;

CStudentt3（3,"ChrisBosh",55）;

CStudentt4（4,"StephenCurry",80）;

CTeacherm;//定义一个教师类的对象

Display（t1）;//输出学生信息

Display（t2）;

Display（t3）;

Display（t4）;

intxuhao;

cout<<"请输入要修改分数的学生的序号：

";//修改成绩

cin>>xuhao;

switch（xuhao）

{

case1:

m.Modify（t1）;break;

case2:

m.Modify（t2）;break;

case3:

m.Modify（t3）;break;

case4:

m.Modify（t4）;break;

}

intv;

cout<<"请输入要查找成绩的学生的序号：

";//查找成绩

cin>>v;

switch（v）

{case1:

m.Displays（t1）;break;

case2:

m.Displays（t2）;break;

case3:

m.Displays（t3）;break;

case4:

m.Displays（t4）;break;

}

return0;

}

实验结果

第三次实验运算符重载对字符串进行比较和运算

设计思路：

设计一个字符串的类，把所要进行的各种运算和操作设计成类的成员函数，另外设计一个字符串类型的数据，作为数据成员，然后，详细写出每个成员函数的实现方法，再在主函数中进行调用，实现字符串之间的运算。

源程序及实验结果

#include//为了实现运算符重载函数作为友元函数用.H文件

//usingnamespacestd;

#include

classString//字符串类

{

public:

String（char*b）;//构造函数的声明

String（）;

friendintoperator>（String&s1,String&s2）;//将运算符重载函数声明为友元函数

friendintoperator<（String&s1,String&s2）;

friendintoperator==（String&s1,String&s2）;

voiddisplay（）//用于输出类的数据成员

{

cout<

}

private:

//数据成员一个字符串

char*a;

};

String:

:

String（char*b）:

a（b）{}//带参数的构造函数

String:

:

String（）//不带参数的构造函数

{a="ABCD";}

intoperator>（String&s1,String&s2）//对‘>’进行运算符重载

{returnstrcmp（s1.a,s2.a）;}

intoperator<（String&s1,String&s2）//对‘<’进行运算符重载

{returnstrcmp（s1.a,s2.a）;}

intoperator==（String&s1,String&s2）//对‘==’进行运算符重载

{returnstrcmp（s1.a,s2.a）;}

voidmain（）//主函数

{

Stringt1（"aa"）,t2（"a"）;//定义两个字符串类的对象并赋初值

cout<<"要进行比较的两个字符串为：

"<

cout<<"t1:

";

t1.display（）;//输出显示要进行比较的两个字符串

cout<<"t2:

";

t2.display（）;

cout<<"式子：

t1>t2"<<"\t";

cout<<（（t1>t2）>0?

"TRUE":

"FALSE"）<'的比较

cout<<"式子：

t1

cout<<（（t1

"TRUE":

"FALSE"）<'的比较

cout<<"式子：

t1==t2"<<"\t";

cout<<（（t1==t2）==0?

"TRUE":

"FALSE"）<

cout<<"字符串比较运算结束！

"<

}

运行结果：

派生类中构造函数与析构函数

#include

usingnamespacestd;

classA//基类A

{

public:

A（）{

a=0,b=0;

flag=0;

cout<<"A0"<

}

A（inti）{

a=i,b=0;

flag=1;

cout<<"A1"<

}

A（inti,intj）{

a=i,b=j;

flag=2;

cout<<"A2"<

}

~A（）{cout<<"~A"<

voiddisplay（）{cout<<"a="<<"b="<

private:

inta,b;

intflag;

};

classB:

publicA

{

public:

B（）{

c=0;

flag=0;

cout<<"B0"<

}

B（inti）:

A（i）{

c=0;

flag=1;

cout<<"B1"<

}

B（inti,intj）:

A（i,j）{

c=0;

flag=2;

cout<<"B2"<

}

B（inti,intj,intk）:

A（i,j）{

c=k;

flag=3;

cout<<"B3"<

}

~B（）{cout<<"~B"<

voiddisplay（）{

A:

:

display（）;cout<<"c="<

private:

intc;

intflag;

};

intmain（）

{

Bb1;

Bb2

（1）;

Bb3（1,3）;

Bb4（1,3,5）;

b1.display（）;

b2.display（）;

b3.display（）;

b4.display（）;

return0;

}

．关于虚函数的一些应用

#include

usingnamespacestd;

classA{//基类

public:

A（）//不带参数的构造函数

{a=0;}

virtualvoiddisplay（）//定义一个虚函数

{cout<<"A的虚函数！

a="<

voiddisplay1（）//定义一个普通成员函数

{cout<<"非虚函数a="<

private:

inta;//定义私有一个成员

};

classB:

publicA{//中间派生类公有方式

public:

B（）:

A（）

{b=1;}

virtualvoiddisplay（）

{cout<<"B的虚函数！

b="<

voiddisplay1（）

{cout<<"非虚函数b="<

private:

intb;

};

classC:

privateA{//直接派生类私有方式

public:

C（）:

A（）

{c=2;}

virtualvoiddisplay（）

{cout<<"C的虚函数！

c="<

voiddisplay1（）

{cout<<"非虚函数c="<

private:

intc;

};

classD:

publicB{//多级派生类公有方式

public:

D（）:

B（）

{d=3;}

virtualvoiddisplay（）

{cout<<"D的虚函数！

d="<

voiddisplay1（）

{cout<<"非虚函数d="<

private:

intd;

};

voidmain（）//主函数

{

A*ceshi;//定义基类指针

Aa1;//分别为ABCD四个类定义一个对象

Bb1;

Cc1;

Dd1;

cout<<"测试A"<

ceshi=&a1;//指针指向对象a

ceshi->display（）;//尝试调用该对象的成员函数

ceshi->display1（）;

/*中间派生类B公有方式*/

cout<<"测试B"<

b1.display（）;//一般对象可调用虚函数

b1.display1（）;//一般对象不可调用非虚函数

ceshi=&b1;//函数，指针指向的是对象的函数，而普通

ceshi->display（）;//函数，在调用指针时，指向的是基类的函数

ceshi->display1（）;//作为中间类，仍然可以通过指针调用虚函数

/*cout<<"测试C"<

ceshi=&c1;私有方式派生的类不可转换，因为在派生

ceshi->display（）;之后，基类的公有部分变私有，外部不可访问

ceshi->display1（）;*/

/*多级派生类D*/

cout<<"测试D"<

ceshi=&d1;//向的是对象的函数,否则，指向基类的函数

ceshi->display（）;

ceshi->display1（）;

cout<<"测试结束"<

}

有关模板的实验

#include

#include

usingnamespacestd;

template

Tminute（TA,TB）//函数模板输出两个中的最小值

{

return（A>B?

B:

A）;

}

template

classCout{

public:

Cout（LEI*a,LEId）

{

b=a;c=d;

}

LEIAVER（）

{

returne/c;

}

LEISUM（）

{

for（inti=1;i

b[i]=b[i]+b[i-1];

e=b[i-1];

returne;

}

private:

LEI*b;

LEIc;

LEIe;

};

intmain（）

{

/*函数模板部分*/

inti1=5,i2=27,i;

/*inti,i1,i2;//整数比较大小可输入

cin>>i1>>i2;*/

doubled1=3.6,d2=3.7,d;

/*doubled1,d2,d;//双精度型数据比较大小可输入

cin>>d1>>d2;*/

strings1="abc",s2="abC",s;

/*strings1,s2,s;//字符串型数据比较大小可输入

cin>>s1>>s2;*/

cout<<"最小的值是：

"<

i=minute（i1,i2）;//调用函数模板

d=minute（d1,d2）;

s=minute（s1,s2）;

cout<

cout<

cout<

/*类模板部分*/

inta[10]={0,1,2,3,4,5,6,7,8,9};//整型数组

Coutzheng（a,10）;//定义类的对象指定类型为int

cout<<"和为：

";

cout<

cout<<"平均值为：

";

cout<

doubleaa[4]={1.2,1.4,1.6,1.8};//双精度数组

Coutshuang（aa,4）;//定义类的对象指定类型为double

cout<<"和为：

";

cout<

cout<<"平均值为：

";

cout<

return0;

}