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

姓名：

学号：

班级：

专业：

学院：

实验三 函数的应用

一、实验目的：

掌握函数的定义 和调用方法；练习重载函数使用；练习函数模板的使用；练习使用系统函数。

二、实验步骤

编写函数float Convert(float TempFer)，参数的返回值都为float类型，实现算法C=(F-32)*5/9，在main()函数中实现输入、输出。

分别编写四个同名函数max1，实现函数重载，在main()函数中测试函数功能。

使用函数模板实现求任意类型数的最大值，针对不同的参数个数，编写两个同名函数模板max1，其参数个数不同，实现函数重载，在main()函数中测试函数的功能。

在main()函数中提示输入两个整数x,y，使用cin语句得到x,y的值，调用pow(x,y)函数计算x的y次幂的结果，再显示出来。

编写递归函数int fib(int n)，在主程序中输入n的值，调用fib函数计算Fibonacci级数。公式为fib(n)=fib(n-1)+fib(n-2)，n＞2;fib(1)=fib(2)=1。使用if语句判断函数的出口，在程序中用cout语句输出提示信息。

三、实验内容及部分代码：

1）编写一个函数把华氏温度转换为摄氏温度，转换公式为：C=(F-32)*5/9。

#include＜iostream.h＞

float Convert(float TempFer)

{

float C,F;

F=TempFer；

C=(F-32)*5/9;

return C;

}

main()

{float C,F;

cin＞＞F＞＞endl;

c=Convert(f);

cout＜＜”摄氏温度:”＜＜endl;

}

2)编写重载函数Max1可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。

#include＜iostream.h＞

int maxl(int a,int b);

int maxl(int a,int b,int c);

int maxl(float a,float b);

int maxl(float a,float b,float c);

int main()

{int A,B,C;float Max;

float D,E,F;

Max=maxl(A,B);

Max=maxl(A,B,C);

Max=maxl(D,E);

Max=maxl(D,E,F);

return 0;

}

int maxl(int a,int b)

{int max;

if(a＞b)

max=a;

else max=b;

return max;

}

int maxl(int a,int b,int c)

{

int max;

max=(a＞b?a:b)＞c?(a＞b?a:b);

return max;

}

float maxl(float a,float b)

{

float max;

if(a＞b)

max=a;

else max=b;

return max;

}

float maxl(float a,float b,float c)

{

float max;

max=(a＞b?a:b)＞c?(a＞b?a:b):c;

return max;

}

3)使用重函数模板重新实现上小题中的函数Max1。

#include＜iostream.h＞

template＜typename T＞

T maxl(T a,T b);

{

return a＞b?a:b;

}

int main()

{

int A,B;

float C,D;

cout＜＜maxl(A,B)＜＜endl;

cout＜＜maxl(C,D)＜＜endl;

return 0;

}

3）使用系统函数pow(x,y)计算xy的值，注意包含头文件math.h。

#include＜iostream.h＞

#include＜math.h＞

main()

{ int x,y;

cin＞＞x＞＞y;

cout＜＜x＜＜"的"＜＜y＜＜"次方为："＜＜pow(x,y)＜＜endl;

}

4）用递归的方法编写函数求Fibonacci级数。

#include ＜iostream.h＞

int fib(int n);

int main()

{ int n,answer;

cout＜＜”Enter number:”;

cin＞＞n;

cout ＜＜”\n\n”;

answer=fib(n);

cout＜＜answer＜＜”is the “＜＜n＜＜”th Fibonnaci number\n”;

return 0;

}

int fib(int n)

{

if(n＜3) return 1;

else return fib(n-2)+fib(n-1);

}

4、实验思考及体会：在本次实验中，；了解到各种函数的运用和性质，以及函数模板的调用，重载函数，函数模板，系统函数的使用。

实验四 类与对象

一、 实验目的：

掌握类的定义和使用

掌握类的定义和对象的声明

复习具有不同访问属性的成员的访问方式。

察构造函数和析构函数的执行过程。

学习类的聚集使用方法。

二、实验步骤：首先定义枚举类型CPU_Rank，例如 enum CPU_Rank{ P1=1,P2,P3,P4,P5,P6,P7},再定义CPU类，包含等级(rank)、频率(frequency)、电压(voltage)等私有数据成员，定义成员函数run、stop，用来输出提示信息，在构造函数和析构函数中也可以输出提示信息。在主程序中定义一个CPU类的对象，调用其成员函数，观察类对象的构造与析构顺序，以及成员函数的调用。

三、实验内容及部分代码：

1）定义一个CPU类，包含等级（rank）、频率（frequency）、电压(voltage)等属性，有两个公有成员函数run、stop。其中rank为枚举类型CPU_Rank，定义一个enum CPU_Rank={P1=1,P2,P3,P4,P5,P6,P7},frequency为单位为MHz的整型数，voltage为浮点型的电压值。

#include ＜iostream.h＞

class CPU {

CPU_Rank rank;

int frequency;

float voltage;

public:

enum CPU_Rank{p1=1, p2, p3, p4, p5, p6, p7};

CPU() {

std::cout ＜＜ "CPU constructive" ＜＜ std::endl;

}

void run() {};

void stop() {};

virtual ~CPU(){

std::cout ＜＜ "CPU destructive" ＜＜ std::endl;

}

};

class RAM {

public:

RAM(){

std::cout ＜＜ "RAM constructive" ＜＜ std::endl;

}

~RAM(){

std::cout ＜＜ "RAM destructive" ＜＜ std::endl;

}

};

class CDROM {

public:

CDROM(){

std::cout ＜＜ "CDROM constructive" ＜＜ std::endl;

}

~CDROM(){

std::cout ＜＜ "CDROM destructive" ＜＜ std::endl;

}

};

class Computer {

private:

CPU cpu;

RAM ram;

CDROM cdrom;

public:

Computer(){

std::cout ＜＜ "Computer constructive" ＜＜ std::endl;

}

void run() {};

void stop() {};

~Computer() {

std::cout ＜＜ "Computer destructive" ＜＜ std::endl;

}

};

int main (int argc, char *argv[]) {

CPU *cpu = new CPU();

Computer *computer = new Computer();

delete cpu;

delete computer;

return 0;

}

2)定义一个简单的Computer类，有数据成员芯片(cpu)、内存(ram)、光驱（cdrom）等等，cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，定义并实现这个类。

#include＜iostream.h＞

enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7};

class CPU

{ private:

CPU_Rank rank;

int frequency;

float voltage;

public:

CPU(CPU_Rank r,int f,float v)

{

rank=r;

frequency=f;

voltage=v;

cout＜＜"构造了一个CPU!"＜＜endl;

}

~CPU(){cout＜＜"析构了一个CPU!"＜＜endl;}

CPU_Rank GetRank()const{return rank;}

int GetFrequency()const{return frequency;}

float GetVoltage()const{return voltage;}

void SetRank(CPU_Rank r){rank=r;}

void SetFrequency(int f){frequency=f;}

void SetVoltage(float v){voltage=v;}

void Run(){cout＜＜"CPU开始运行!"＜＜endl;}

void Stop(){cout＜＜"CPU停止运行!"＜＜endl;}

};

class RAM //定义RAM类

{

int x;

public:

RAM(int a){x=a;

cout＜＜"构造了一个RAM!"＜＜endl;}

~RAM(){cout＜＜"析构了一个RAM!"＜＜endl;}

};

class CDROM //定义CDROM类

{

char y;

public:

CDROM(char v){y=v;cout＜＜"构造了一个CDROM!"＜＜endl;}

~CDROM(){cout＜＜"析构了一个CDROM!"＜＜endl;}

};

class Computer //定义Computer类

{

CPU a;

RAM b;

CDROM c;

public:

Computer(CPU_Rank x,int y,float z,int xx,char yy)//构造函数

:a(x,y,z),b(xx),c(yy)

{

cout＜＜"构造了一个Computer!"＜＜endl;}

~Computer(){cout＜＜"析构了一个Computer!"＜＜endl;}

void Run(){cout＜＜"Computer开始运行!"＜＜endl;}

void Stop(){cout＜＜"Computer停止运行!"＜＜endl;}

};

void main()

{

Computer niu(P6,3,2.9,4,'G');

niu.Run();

niu.Stop();

}

3)设计一个用于人事管理的People（人员）类。考虑到通用性，这里只抽象出所有类型人员都具有的属性：number(编号)、sex(性别)、birthday(出生日期)、id(身份证号)等等。其中“出生日期”定义为一个“日期”类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数。

#include ＜iostream＞

#include ＜string＞

class Date //日期类

{

private:

int year;

int month;

int day;

public:

Date(){} //默认构造

Date(int y,int m,int d) //带参构造

{

year=y;

month=m;

day=d;

}

void set() //设置数据函数

{

cin＞＞year＞＞month＞＞day;

}

void display() //显示函数

{

cout＜＜year＜＜'/'＜＜month＜＜'/'＜＜day;

}};

class Person //人员类

{

private:

int num;

char sex;

Date birthday;

char ID[19];

public:

Person(){} //默认构造

Person(int n,int y,int m,int d,char id[19],char s='m'):birthday(y,m,d)

{

num=n;

sex=s;

strcpy(ID,id);

} //有默认值的带参构造

Person(Person& p) //拷贝构造

{

num=p.num;

sex=p.sex;

birthday=p.birthday;

strcpy(ID,p.ID);

}

void input() //输入函数

{

cout＜＜"录入数据："＜＜endl;

cout＜＜"编号：";

cin＞＞num;

cout＜＜"性别(m/f)：";

cin＞＞sex;

cout＜＜"生日：";

birthday.set();

cout＜＜"身份证号：";

cin＞＞ID;

ID[18]='\0';

cout＜＜endl;

}

void output() //输出函数

{

cout＜＜"编号："＜＜num＜＜endl;

cout＜＜"性别："＜＜sex＜＜endl;

cout＜＜"生日：";

birthday.display();

cout＜＜endl;

cout＜＜"身份证号："＜＜ID＜＜endl;

}

~Person() //析构函数

{

cout＜＜num＜＜"号人员信息已删除。"＜＜endl;

}

};

int main()

{

Person p1;

p1.input();

p1.output();

return 0;

}

4、实验思考及体会：通过本次试验更加了解了C++中类与对象的含义，类和函数的互相使用，以及类的编写和使用。

实验五 C++程序的结构

一、实验目的

观察程序运行中变量的作用域、生存期和可见性。

学习类的静态成员的使用。

学习多文件结构在C++程序中的使用。

二、实验步骤

1． 运行程序lab5_1，观察程序输出。

全局变量的作用域为文件作用域，在整个程序运行期间有效，但如果在局部模块中定义了同名的变量，则在局部模块中，可见的是局部变量，此时，全局变量不可见；而局部变量的生存期只限于相应的程序模块中，离开相应的程序模块，局部变量x、y就不再存在，此时同名的全局变量重新可见。

2． 新建一个空的项目lab5_2，添加头文件client.h，在其中定义类CLIENT，注意使用编译预处理命令；再添加原程序文件client.cpp，在其中实现CLIENT类，注意静态成员变量的使用方法，再添加文件lab5_2.cpp，在其中定义main（）函数，测试CLIENT类，观察相应的成员变量取值的变化情况。

3、实验内容及部分代码：

1）运行下面的程序，观察变量x、y的值。

#include＜iostream.h＞

void fnl();

int x=1,y=2;

int main()

{

cout＜＜"Begin..."＜＜endl;

cout＜＜"x="＜＜x＜＜endl;

cout＜＜"y="＜＜y＜＜endl;

cout＜＜"Evaluate x and y in main()..."＜＜endl;

int x=10, y=20;

cout＜＜"x="＜＜x＜＜endl;

cout＜＜"y="＜＜y＜＜endl;

cout＜＜"Step into fnl()..."＜＜endl;

fnl();

cout＜＜"Back in main"＜＜endl;

cout＜＜"x="＜＜x＜＜endl;

cout＜＜"y="＜＜y＜＜endl;

return 0;

}

void fnl()

{

int y=20;

cout＜＜"x="＜＜x＜＜endl;

cout＜＜"y="＜＜y＜＜endl;

}

经运行，实验运行结果：Begin...

x=1

y=2

Evaluate x and y in main()...

x=10

y=20

Step into fnl()...

x=1

y=20

Back in main

x=10

y=20；

2）现客户机（CLIENT）类。定义字符型静态数据成员ServerName,保存其服务器名称；整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeSeverName()改变服务器名称。在头文件client.h中定义类，在文件client.cpp中实现，在test.cpp中测试这个类，观察相应的成员变量取值的变化情况。

client.h文件:

class CLIENT

{

private:

static char[10] ServerName; //保存其服务器名称

static int ClientNum; //记录已定义的客户数量

public:

ChangeServerName(); //改变服务器名称

};

4、实验思考及体会：通过本次实验，了解域的性质和使用情况，对字符串，数据组的使用，静态动态数据组的使用。

实验六 数组、指针与字符串

1、实验目的：

学习使用数组。

学习字符串数据的组织和处理。

学习标准C++库的使用。

掌握指针的使用方法。

练习通过debug观察指针的内容及其所指的对象的内容。

练习通过动态内存分配实现动态数组，并体会指针在其中的作用。

分别使用字符数组和标准C++库练习处理字符串的方法。

2、实验步骤：

1、编写矩阵转置函数，输入参数为3*3整型数组，使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作，编写main()函数实现输输出。。

2、改写矩阵转置函数，参数为整型指针，使用指针对数组元素进行操作，在main()函数中 new 操作符分配内存生成动态数组。

3、编程实现两字符串的连接。定义字符数组保存字符串，在程序中提示用户输入两个字符串，实现两个字符串的连接，最后用count 语句显示输出。用 cin 实现输入，注意，字符串的结束标志是ASCII码 0，使用循环语句进行字符串间的字符拷贝。

使用string类定义字符串对象，编程实现两字符串的连接。在string类中已重载了运算符“+ =”实现字符串的连接，可以使用这个功能。

4、在employee.h文件中定义Employee类， EmpLoyee类具有姓名、街道地址、城市和邮遍等私有数据成员，都可以用字符型数组来表示，在成员函数中，构造函数用来初始化所有成员数组，对字符数组的赋值可以使用字符串拷贝函数 strcpy(char *,char * name);display()中使用count显示姓名、街道地址、城市和邮遍等属性，chang_name()改变类中表示姓名属性的字符数组类型的数据成员。在主程序中定义这个类的对象并对其进行操作。

5、使用上一小题中定义的Employee类定义对象数组enp[5]，使用循环语句把数据显示出来。

三、实验内容及部分代码：

1）编写并测试3*3 矩阵转置函数，使用数组保存 3*3 矩阵。

#include＜iostream.h＞

void main()

{

int a[3][3],i,j,b[3][3];

cout＜＜"请依次输入距阵中的元素:"＜＜endl;

for( i=0;i＜3;i++)

{

for( j=0;j＜3;j++)

{

cin＞＞a[i][j];

}

}

cout＜＜"此矩阵中的元素为:"＜＜endl;

for( i=0;i＜3;i++)

{

for( j=0;j＜3;j++)

{

cout＜＜a[i][j];

cout＜＜" ";

}

cout＜＜endl;

}

cout＜＜"经过转置后矩阵为:"＜＜endl;

for( i=0;i＜3;i++)

{

for( j=0;j＜3;j++)

{

b[i][j]=a[j][i];

cout＜＜b[i][j];

cout＜＜" ";

}

cout＜＜endl;

}

}

使用动态内存分配生成动态数组来重新完成上题，使用指针实现函数的功能

#include＜iostream.h＞

#include＜stdlib.h＞

void print(int *a)

{

for(int i=0;i＜9;i++)

{

cout＜＜*a;

cout＜＜" ";

a++;

if((i+1)%3==0)cout＜＜endl;

}

}

void reserve(int *&a)

{

int b[3][3],i,j;

int *c;

c=a;

for(i=0;i＜3;i++)

{

for(j=0;j＜3;j++)

{

b[i][j]=*a;

a++;

}

}

a=c;

for(i=0;i＜3;i++)

{

for(j=0;j＜3;j++)

{

*a=b[j][i];

a++;

}

}

a=c;

}

void main()

{

int i,j;

int *a,*b;

a=(int *)new int[3][3];

b=a;

cout＜＜"请依次输入距阵中的元素:"＜＜endl;

for(i=0;i＜9;i++)

{

cin＞＞*a;

a++;

}

a=b;

cout＜＜"此距阵中的元素为:"＜＜endl;

print(a);

reserve(a);

cout＜＜"经过转置后此距阵为:"＜＜endl;

print(a);

}

2）编程实现两字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。

使用sting类定义字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。

#include ＜iostream＞

using namespace std;

int main()

{

char str1[40];

char str2[20];//保证被连接字符串长度大于待连接字符串的长度.

int counter1=0,counter2=0;//计数器

cout＜＜"请输入第一个字符串: ";

cin＞＞str1;

cout＜＜"\n请输入第二个字符串: ";

cin＞＞str2;

while(str1[counter1]!='\0') //这个循环用于找到第一个字符串的最后一字符位置

++counter1; //counter1用于记录这个位置

while(str2[counter2]!='\0')

{

str1[counter1-1]=str2[counter2]; //从第一个字符串的末尾开始复制

++counter1;

++counter2;

}

str1[counter1]='\0'; //将字符串的结束位改成 连接后的字符串的末尾

cout＜＜"\n连接后的字符串:　"＜＜str1;

}

3）定义一个Employee类，其中包括姓名、街道地址、城市和邮遍等属性。以及 change_name() 和display()等函数。display()显示姓名、街道地址、城市和邮遍等属性，change_name()改变对象的姓名。

#include ＜iostream＞

using namespace std;

class Employee {

private:

char *name,*address,*city,*postCode;

public:

Employee(char *_name,char *_address,char *_city,char *_postCode)

{

name = _name;

address = _address;

city = _city;

postCode = _postCode;

}

void change_name(char *_name){

name = _name;

}

void display()

{

cout ＜＜ "name : " ＜＜ name ＜＜ endl;

cout ＜＜ "address : " ＜＜ address ＜＜ endl;

cout ＜＜ "city : " ＜＜ city ＜＜ endl;

cout ＜＜ "postcode : " ＜＜ postCode ＜＜ endl;

}

};

int main(int argc,char *argv[])

{

Employee *e = new Employee("zhangsan","chang d d","beijing","100056");

e-＞display();

e-＞change_name("lisi");

e-＞display();

delete e;

}

4、实验思考及体会：通过本次实验，了解了指针变量可以指向任何类型的对象，它指向数组、结构、函数、数组的数组元素等。同时对多维数组也有了深刻的认识。

实验七、继承与派生(一、二)

1、实验目的：

学习定义和使用类的继承关系，定义派生类。

熟悉不同继承方式下对基类成员的访问控制。

学习利用虚基类解决二义性问题。

二、实验步骤

编写程序定义基类Animal，成员变量age定义为私有的。构造派生类dog，在其成员函数SetAge(int n)中直接对age赋值时，会出现类似以下的错误提示：

error C2248:’age’:cannot access private member declared in class ‘Animal’

error C2248:’age’:cannot access private member declared in class ‘Animal’

把age改为公有成员变量后重新编译就可以了。(2） 编写程序定义一个基类BassClass，构造其派生类DerivedClass，在构造函数和析构函数中用cout输出提示信息，观察构造函数和析构函数的执行情况。程序名为：lab7_2.cpp。

(3） 用debug功能跟踪程序lab7_2的执行过程，观察基类和派生类的构造函数和析构函数的执行情况。

写程序定义一个车(vehicle)基类，由此派生出自行车（bicycle）类、汽车类(motorcar)类，注意把vehicle派生为虚基类。再从bicycle和motorcar派生出摩托车(motorcycle)类，在main()函数中测试这个类。程序名为:lab7_3.cpp。

编译成功后，把vehicle设置为非虚基类，再编译一次，此时系统报错，无法编译成功。这是因为若不把vehicle设置为虚基类，会出现二义性错误，程序不能成功编译。

3、实验内容及部分代码：

1）定义一个基类Animal，有私有整型成员变量age,构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把age改为公有成员变量，还会有问题吗？

# include ＜iostream＞

using namespace std;

class Animal

{

public:

Animal()

{

cout ＜＜ "Aninmal is constructed!"＜＜endl;

}

~Animal()

{

cout ＜＜ "Aninmal is deconstructed!"＜＜endl;

};

void SetAge(int n)

{

age=n;

}

int GetAge()

{

return age;

}

private :

int age;

char name;

};

class Dog:public Animal

{

public:

Dog()

{

cout ＜＜ "Dog is constructed!"＜＜endl;

}

~Dog()

{

cout ＜＜ "Dog is constructed!"＜＜endl;

}

};

int main()

{

Dog dog;

dog.SetAge(12);

cout ＜＜"age=" ＜＜dog.GetAge() ＜＜endl;

return 0;

}

运行结果：Aninmal is constructed!

Dog is constructed!

age=12

Dog is constructed!

Aninmal is deconstructed!

2）定义一个基类BaseClass，有整型成员变量Number ,构造其派生类DerivedClass，观察构造函数和析构函数的执行情况。

#include＜iostream＞

using namespace std;

class baseclass{

public:

int number;

baseclass(){}

baseclass(int);

};

class derivedclass:public baseclass{

public:

int number_derived;

derivedclass(){}

derivedclass(int);

};

baseclass::baseclass(int num)

{

number = num;

cout＜＜number＜＜endl;

cout＜＜"call base class"＜＜endl;

}

derivedclass::derivedclass(int num)

{

number_derived = num;

cout＜＜number_derived＜＜endl;

cout＜＜"call derived class"＜＜endl;

}

int main()

{

baseclass Base(10);

derivedclass DBase(29);

return 1;

}

运行结果：10

call base class

29

call derived class；

3）定义一个车(vehicle)基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类。自行车类有高度(height)等属性，汽车类有座位数(SeatNum)等属性。从bicycle和motorcar派生出摩托车(motorcycle)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle设置为虚基类，会有什么问题？编程试试看。

#include＜iostream＞

using namespace std;

class Vehicle {

double MaxSpeed;

double Weight;

void Run(){};

void Stop(){}

}

class Bicycle extends Vehicle{

double Height;

void Run(){

System.out.println("I can 2!");

}

}

class Motocar extends Vehicle{

double SeatNum;

void Run(){

System.out.println("I can 3!");

}

}

class Motorcycle extends Vehicle{

void Run(){

System.out.println("I can 4!");

}

}

public class question2_7 {

public static void main(String[] args) {

Vehicle a=new Motorcycle();

Vehicle b=new Motocar();

a.Run();

b.Run();

}

}

Int main()

{

Vehicle (10)

}

4、实验思考及体会：通过本次实验了解了 ：派生类是基类的具体化，而基类则是派生类的抽象。同时对正在进行多继时，出现的二义性问题有了了解。

实验八、多态性

1、实验目的：

掌握运算符重载的方法

习使用虚函数实现动态多态性。

2、实验步骤

1/编写程序定义Point类，在类中定义整型的私有成员变量x,y，定义成员函数Point& operator++();Point operator++(int);以实现对Point类重载“++”运算符，定义成函数Point& operator –();Point operator - -(int);以实现对Point类重载“- -”运算符，实现对坐标值的改变。

2、编写程序定义一个车(vehicle)基类，有Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车类（motorcar），从bicycle类和motorcar类派生出摩托车类（motorcycle），它们都有Run、Stop等成员函数。在main()函数中定义vehicle、bicycle、motorcar、motorcycle的对象，调用其Run()、Stop()函数，观察其执行情况。再分别用vehicle类型的指针来调用几个对象的成员函数，看看能否成功；把Run、Stop定义为虚函数，再试看。

3、实验内容及部分代码：

1）定义Point类，有坐标x,y两个成员变量；对Point类重载“++”、“- -”运算符，实现对坐标值的改变。

#include ＜iostream.h＞

class Point

{

private:

int x;

int y;

public:

Point (int a,int b){x=a;y=b;}

Point &operator ++(int);

Point &operator --(int);

Point &operator ++();

Point &operator --();

void print();

};

Point &Point::operator++(int)

{return Point(x++,y++);}

Point &Point::operator--(int)

{return Point(x--,y--);}

Point &Point::operator++()

{return Point(++x,++y);}

Point &Point::operator--()

{return Point(--x,--y);}

void Point::print()

{cout＜＜"x="＜＜x＜＜"\ty="＜＜y＜＜endl;}

main()

{ Point a1(2,3);

a1++;

a1.print();

}

2）定义一个车(vehicle)基类，有Run、Stop等成员函数，由此派生出自行车（bicycle）类、汽车(motorcar)类，从bicycle和motorcar派生出摩托车(motorcycle)类，它们都有Run、Stop等成员函数。观察虚函的作用。

#include＜iostream.h＞

class vehicle // 定义汽车类

{

protected:

int wheels; // 车轮数

float weight; // 重量

public:

vehicle(int wheels,float weight);

int get_wheels();

float get_weight();

float wheel_load();

void show();

};

class car:public vehicle // 定义小车类

{

int passenger_load; // 载人数

public:

car(int wheels,float weight,int passengers=4);

int get_passengers();

void show();

};

class truck:public vehicle // 定义卡车类

{

int passenger_load; // 载人数

float payload; // 载重量

public:

truck(int wheels,float weight,int passengers=2,float max_load=24000.00);

int get_passengers();

float efficiency();

void show();

};

vehicle::vehicle(int wheels,float weight)

{

vehicle::wheels=wheels;

vehicle::weight=weight;

}

int vehicle::get_wheels()

{

return wheels;

}

float vehicle::get_weight()

{

return weight/wheels;

}

void vehicle::show()

{

cout ＜＜ "车轮:" ＜＜ wheels ＜＜ "个" ＜＜ endl;

cout ＜＜ "重量:" ＜＜ weight ＜＜ "公斤" ＜＜ endl;

}

car::car(int wheels, float weight,

int passengers) :vehicle (wheels, weight)

{

passenger_load=passengers;

}

int car::get_passengers ()

{

return passenger_load;

}

void car::show()

{

cout ＜＜" 车型:小车" ＜＜ endl;

vehicle::show();

cout ＜＜ "载人:" ＜＜ passenger_load ＜＜ "人" ＜＜ endl;

cout ＜＜ endl;

}

truck:: truck(int wheels, float weight,int passengers, float max_load):vehicle(wheels,weight)

{

passenger_load=passengers;

payload=max_load;

}

int truck::get_passengers()

{

return passenger_load;

}

float truck::efficiency()

{

return payload/(payload+weight);

}

void truck::show()

{

cout ＜＜"车型:卡车" ＜＜ endl;

vehicle:: show ();

cout ＜＜ "载人:" ＜＜ passenger_load ＜＜ "人" ＜＜ endl;

cout ＜＜ "效率:" ＜＜ efficiency() ＜＜ endl;

cout ＜＜ endl;

}

void main ()

{

car car1(4,2000,5);

truck tru1(10,8000,3,340000);

cout ＜＜ "输出结果" ＜＜ endl;

car1. show ();

tru1. show ();

}

四、实验思考及体会：通过本次实验了解了：C++中的多态分为静多态和动多态，静动的区别主要在于这种绑定发生在编译期还是运行期，发生在编译期的是静态绑定，也就是静多态；发生在运行期的则是动态绑定，也就是动多态。