C++上机实验报告

第一篇：C++上机实验报告

C++上机实验报告

实验名称：实验

专业班级：

姓

名：

学

号：

实验日期： 11 实验

目录

1.实验目的

2.实验内容

3.程序代码

4.调试结果

5.实验心得 1.实验目的 实验10（1）进一步了解运算符重载的概念和使用方法；（2）掌握几种常用的运算符重载的方法；（3）了解转换构造函数的使用方法；

（4）了解在Visual C++6.0环境下进行运算符重载要注意的问题。实验11（1）了解继承在面向对象程序设计中的重要作用；（2）进一步理解继承和派生的概念；

（3）掌握通过继承派生出一个新的类的方法；（4）了解虚基类的作用和用法。

2.实验内容 实验10 事先编好程序，上机进行调试和运行程序，分析结果。（1）声明一个复数类Complex，重载运算符“+”，“-”，“*”，“/”，使之能用于复数的加，减，乘，除，运算符重载函数作为Complex类成员的函数。编程序，分别求两个复数之和，差，积和商。（2）声明一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。

运行程序，分别求两个复数之和，整数和复数之和，（3）有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于两个矩阵相加

（4）声明一个Teacher（教师）类和一个Student（学生）类，二者有一部分数据成员是相同的，例如num（号码），name（名字），sex（性别）。编写程序，将一个Student对象（学生）转换为Teacher（教师）类，只将以上三个相同的数据成员移植过去。可以设想为：一位学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说任然是有用的，应当保留并成为其教师的数据的一部分。

实验11

事先编写好程序，上机调试和运行程序，分析结果。

（1）将教材第11章例11.1的程序片段补充和改写成一个完整的、正确的程序，用公用继承方式。在程序中应当包括输入数据的函数，在程序运行时输入num，name，sex，age，addr的值，程序应输出以上5个数据的值。

（2）将教材第11章例11.3的程序修改、补充，写成一个完整、正确的程序，用保护继承方式。在程序中应包括输入数据的函数。（3）修改上面第（2）题的程序，改为用公用继承方式。上机调试程序，使之能够正确运行并得到正确的结果。

对这两种继承方式做比较分析，考虑在什么情况下二者不能互相替换。

（4）分别声明Teacher（教师）类和Cadre（干部）类，采用多 重继承方式由这两个类派生出新类Teacher-Cadre（教师兼干部）。要求：

Ⅰ.在两个基类中都包含姓名、年龄、性别、地址、电话等数据成员。

Ⅱ.在Teacher类中还包含数据成员title（职称），在Cadre类中还包含数据成员post（职务）。在Teacher-Cadre类中还包含数据成员wages（工资）。

Ⅲ.在基类中的姓名、年龄、性别、地址、电话等数据成员用相同的名字，在引用这些数据成员时，指定作用域。Ⅴ.在类体中声明成员函数，在类外定义成员函数。

Ⅵ.在派生类Teacher-Cadre的成员函数show中调用Teacher类中的display函数，输出性命、年龄、性别、职称、地址、电话，然后再用cout语句输出职务与工资。

3.程序代码 实验10（1）

#include using namespace std;class Complex {public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex operator +(Complex &c2);Complex operator-(Complex &c2);Complex operator*(Complex &c2);Complex operator/(Complex &c2);void display();private: double real;double imag;};

Complex Complex::operator +(Complex &c2){Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;}

Complex Complex::operator-(Complex &c2){Complex c;c.real=real-c2.real;c.imag=imag-c2.imag;return c;}

Complex Complex::operator*(Complex &c2){Complex c;c.real=real*c2.real-imag*c2.imag;c.imag=imag*c2.real+real*c2.imag;return c;}

Complex Complex::operator/(Complex &c2){Complex c;c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);return c;} void Complex::display(){cout<<“(”<

（2）

#include using namespace std;class Complex {public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c2);Complex operator+(int &i);friend Complex operator+(int &,Complex &);void display();private:

double real;

double imag;};

Complex Complex::operator+(Complex &c){return Complex(real+c.real,imag+c.imag);}

Complex Complex::operator+(int &i){return Complex(real+i,imag);}

void Complex::display(){cout<<“(”<

Complex operator+(int &i,Complex &c){return Complex(i+c.real,c.imag);}

int main(){Complex c1(3,4),c2(5,-10),c3;int i=5;c3=c1+c2;cout<<“c1+c2=”;c3.display();c3=i+c1;cout<<“i+c1=”;c3.display();c3=c1+i;cout<<“c1+i=”;c3.display();return 0;}（3）

#include using namespace std;class Matrix {public: Matrix();friend Matrix operator+(Matrix &,Matrix &);void input();void display();private:

int mat[2][3];};

Matrix::Matrix(){for(int i=0;i<2;i++)for(int j=0;j<3;j++)mat[i][j]=0;}

Matrix operator+(Matrix &a,Matrix &b){Matrix c;for(int i=0;i<2;i++)for(int j=0;j<3;j++){c.mat[i][j]=a.mat[i][j]+b.mat[i][j];} return c;}

void Matrix::input(){cout<<“input value of matrix:”<>mat[i][j];}

void Matrix::display(){for(int i=0;i<2;i++){for(int j=0;j<3;j++){cout<

#include using namespace std;class Student {public: Student(int,char[],char,float);int get_num(){return num;} char * get_name(){return name;} char get_sex(){return sex;} void display(){cout<<“num:”<

int num;

char name[20];

char sex;

float score;};

Student::Student(int n,char nam[],char s,float sco){num=n;strcpy(name,nam);sex=s;score=sco;}

class Teacher {public: Teacher(){} Teacher(Student&);Teacher(int n,char nam[],char sex,float pay);void display();private:

int num;

char name[20];

char sex;

float pay;};

Teacher::Teacher(int n,char nam[],char s,float p} {num=n;strcpy(name,nam);sex=s;pay=p;}

Teaxher::Teacher(Student& stud){num=stud.get_num();strcpy(name,stud.get_name());sex=stud.get.sex();pay=1500;}

void Teacher::display(){cout<<“num:”<int main(){Teacher teacher1(10001,”Li“,'f',1234.5),teacher2;Student student1(20010,”Wang“,'m',89.5);cout<<”student1:“<

#include using namespace std;class Student {public:

void get_value()

{cin>>num>>name>>sex;}

void display()

{cout<<”num:“<

cout<<”sex:“<

int num;

char name[10];char sex;};

class Student1:public Student {public: void get_value_1(){get_value();cin>>age>>addr;} void display_1(){cout<<”age:“<

char addr[30];};

int main(){Student1 stud1;stud1.get_value_1();stud1.display();stud1.display_1();return 0;}（2）

#include using namespace std;class Student {public: void get_value();

void display();protected: int num;

char name[10];

char sex;};

void Student::get_value(){cin>>num>>name>>sex;} void Student::display(){cout<<”num:“<

class Student1:protected Student {public: void get_value_1();void display1();private: int age;char addr[30];};

void Student1::get_value_1(){get_value();cin>>age>>addr;} void Student1::display1(){cout<<”num:“<

int main(){Student1 stud1;stud1.get_value_1();stud1.display1();return 0;}（3）

#include using namespace std;class Student {public: void get_value();void display();protected:

int num;

char name[10];

char sex;};

void Student::get_value(){cin>>num>>name>>sex;}

void Student::display(){cout<<”num:“<

class Student1:public Student {public: void get_value_1();void display1();private:

int age;

char addr[30];};

void Student1::get_value_1(){get_value();cin>>age>>addr;} void Student1::display1(){cout<<”num:“<

int main(){Student1 stud1;stud1.get_value_1();stud1.display1();return 0;}（4）

#include #include using namespace std;class Teacher {public:

Teacher(int,char[],char);void display();private: int num;char name[20];char sex;};

Teacher::Teacher(int n,char nam[],char s){num=n;strcpy(name,nam);sex=s;}

void Teacher::display(){cout<<”num:”<

class BirthDate {public: BirthDate(int,int,int);void display();void change(int,int,int);private: int year;int month;int day;};

BirthDate::BirthDate(int y,int m,int d){year=y;month=m;day=d;}

Void BithDate::display(){cout<<”birthday:”<

void BirthDate::change(int y,int m,int d){year=y;month=m;day=d;}

class Professor:public Teacher {public: Professor(int,char[],char,int,int,int,float);void display();void change(int,int,int);private: float area;BirthDate birthday;}

Professor::Professor(int n,char name[20],char s,int y,int m,int d,float a): Teacher(n,name,s),birthday(y,m,d),area(a){}

void Professor::display(){Teacher::display();birthday.display();cout<<”area:”<

Int main(){Professor profl(3012,”Zhang”,’f’,1949,10,1,125.4);cout<

4.调试结果

实验10（1）c1+c2=(8,-6i)c1-c2=(-2,14i)c1*c2=(55,-10i)c1/c2=(-0.2,0.4)（2）c1+c2=(8,-6i)i+c1=(8,4i)c1+i=(8,4i)

（3）

input value of Matrix:11 22 33 44 55 66 input value of Matrix:12 13 14 15 16 17 Matrix a: 11 22 33 44 55 66 Matrix b: 12 13 14 15 16 17 Matrix c=Matrix a + Matrix b : 23 25 47 59 71 83

（4）student1 : num :20010 name:Wang sex:m score；89.5 Teacher2: num:20010 name:Wang sex:m pay:1500

实验11（1）

10101 Li M 20 Beijing num:10101 name:Li sex:M age:20 address:Beijing

（2）

10101 Li M 20 Beijing num:10101 name:Li sex:M age:20 address:Beijing

（3）

10101 Li M 20 Beijing num:10101 name:Li sex:M age:20 address:Beijing

（4）The original data: num:3012 name:Zhang sex:f area:125.4

The new data: num:3012 name:Zhang sex:f birthday:6/1/1950 area:125.4 5.实验心得

这一次上机实验，除了了解到了运算符重载的概念和用法，掌握几种常用的运算符重载的方法，了解转换构造函数的使用方法，同时也能了解虚基类的用法，理解继承与派生的概念。

但是，最主要的，我觉得，是通过这一次的上机实验，我了解到，有的实验本身是没有程序错误的，但是，也会由于实验环境的影响而不能正常运行。换句话说，有的程序并不能在Visaul C++的环境下运行，而不是程序自身的问题。所以，对于没办法调试成功的程序，我们也不能一味的认为程序有错误，要学会理性的判断程序的对错，再下结论。

第二篇：C++上机实验报告

第二次上机实验报告

姓名：王小宁

班级：

学号：

031012 1234

第一题：

题目：

编写一个类，声明一个数据成员和一个静态数据成员，其构造函数初始化数据成员，并把静态数据成员加1，其析构函数把静态数据成员减1.（1）编写一个应用程序，创建该类的3个对象，然后显示其数据成员和静态数据成员，再析构每个对象，并显示它们对静态数据成员的影响。

（2）修改该类，增加静态成员函数并访问静态数据成员，并声明静态数据成员为保护成员。体会静态成员函数的使用，静态成员之间与非静态成员之间互访问题。

编程思想：

首先，定义一个类，其中含有两个类的私有变量，一个静态数据变量，定义构造函数，将初值赋给两个私有变量，并将静态数据变量加1，并显示.定义一个析构函数，并通过析构函数将静态成员变量减1.并显示。

修改以上的类，增加一个静态成员函数并通过静态成员函数来访问静态成员变量。在主函数中利用一个指向函数的指针指向这个静态成员函数，并通过这个指针来访问类中的静态数据。代码实现：

代码1：

#include using namespace std;class A { public:

static int count;

A(int a=0,int b=0)

{

X=a;

Y=b;

count++;

cout<<“startcount=”<

count--;

cout<<“overcount=”<

int GetX(){return X;}

int GetY(){return Y;}

private:

int X,Y;};int A::count=0;int main(){ int *countp=&A::count;A z(2,3);cout<<“x=”<

cout<<“x=”<

问题及心得：

在这次试验中，我理解了静态变量与普通变量之间的差异与联系。在实验过程中因未初静态变量始化而无法通过编译，并且注意到静态变量一定要在类外初始化。

题目2：

创建一个Person类，该类中有字符数组，表示姓名、街道地址、市、省和邮政编码。其功能有修改姓名、显示数据信息。要求其功能函数的原型放在类定义中，构造函数初始化每个成员，显示信息函数要求把对象中的完整信息打印出来。其中数据成员为保护的，函数为公有的。

编程思想：

创建一个PERSON类，定义姓名、街道地址、市、省和邮政编码分别为CHAR型的指针私有型变量。在定义公有型的构造函数，并在构造函数中申请动态内存来保存初始化的内容，并用相应的私有性的指针变量指向，再利用复制函数则指针中将会存放入输入内容。定义公有的析构函数释放动态申请的空间。定义一个公有的改变函数改变其中一个变量，方法与构造函数相似。

代码实现：

#include using namespace std;class Person {

private:

char *name;char *street;char *pro;char *city;char *code;

public: Person(char *aname,char *astreet,char *apro,char *acity,char *acode){

name=new char[strlen(aname)+1];

strcpy(name,aname);

street=new char[strlen(astreet)+1];

strcpy(street,astreet);

pro=new char[strlen(apro)+1];

strcpy(pro,apro);

city=new char[strlen(acity)+1];

strcpy(city,acity);

code=new char[strlen(acode)+1];

strcpy(code,acode);

cout<<“constructor”<

delete[] name;

delete[] street;

delete[] pro;

delete[] city;

delete[] code;

cout<<“destructor”<

delete[] name;

name=new char[strlen(aname)+1];

strcpy(name,aname);} void show(){

cout<<“姓名：”<

cout<<“街道地址：”<

cout<<“省份：”<

cout<<“城市：”<

cout<<“邮政编码：”<

运行结果：

实验心得： 通过这个实验，我们学会了对类的私有的字符数组变量的初始化。利用指针动态分配空间。

第三篇：C++上机实验报告5（定稿）

C++程序实验报告

实验五继承与派生 实验目的

1.学习定义和使用类的继承关系，定义派生类 2.熟悉不同继承方式下对基类成员的访问控制 3.学习利用虚基类解决二义性问题 实验要求

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

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

3.定义一个车（vehicle）基类，具有Maxspeed、Weight等成员，Run、Stop等成员函数，由此派生出自行车（bicycle）类、汽车（motorcar）类。自行车（bicycle）类有高度（Height）等属性，汽车（motorcar）类有座位数（SeatNun）等属性。从bicycle和motorcar派生出摩托车（motorbicycle）类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle设置为虚基类，会有什么问题？编程尝试。实验内容及实验步骤

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改为公有成员变量后重新编译就可以了。程序名：lab7_1.cpp。错误代码：

#include using namespace std;

class Animal { private: int age;public: Animal(){};};

class dog:public Animal { public: void SetAge(int n){

age=n;};};

int main(){ dog one;one.SetAge(23);return 0;}

运行结果：

正确代码：

#include using namespace std;

class Animal { public: int age;public: Animal(){};};

class dog:public Animal { public: void SetAge(int n){

age=n;};};

int main(){ dog one;one.SetAge(23);return 0;}

运行结果：

2.编写程序定义一个基类BaseClass，构造其派生类DerivedClass，在构造函数和析构函数中用cout输出提示信息，观察构造函数和析构函数的执行情况。程序名：lab7_2.cpp。

源代码：

#include using namespace std;class BaseClass { private: int a;public: BaseClass(){

cout<<“基类构造函数调用”<

cout<<“基类析构函数调用”<

class DerivedClass:public BaseClass { private: int b;public: DerivedClass(){

};cout<<“派生类构造函数调用”<

cout<<“派生类析构函数调用”<

int main(){ DerivedClass one;

return 0;}

运行结果：

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

DEBUG：

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

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

#include using namespace std;

class Vehicle { public: Vehicle(){};int a;void set(){

cout<<“Vehicle调用”<

class Mortorcar:virtual public Vehicle { public: Mortorcar(){};int b;void set(){

cout<<“Mortorcar调用”<

class Bicycle:virtual public Vehicle { public: Bicycle(){};int c;void set(){

cout<<“Bicycle调用”<

class Mortorcycle:public Mortorcar,public Bicycle { public: Mortorcycle(){};int d;void set(){

cout<<“Mortorcycle调用”<

int main(){ Mortorcycle one;one.a =1;one.b=2;one.set();return 0;} 运行结果：

错误情况：

思考题

1.如何在已有的类的基础上设计新的类？

派生一个新的类。

2.基类和派生类对象的构造顺序是怎样的？

先调用基类的构造函数在调用派生类的构造函数。3.如何利用虚基类解决二义性问题？ 将共同的基类设置为虚基类，这时从不同的路径继承过来的同名数据成员在内存中就只有一个副本，同一个函数名也只有一个映射。

第四篇：C++实验报告

姓名：XX 学院：XXX 班级：XXX 学号：XXX

i++;

} while(i<=10);cout<<“sum=”<

#include using namespace std;void main(){ int i(1),sum(0);

for(i;i<=10,i++)

{

sum+=i;

}

cout<<“sum=”< using namespace std;const float pi=3.1416;void main(){ int itype;

cout<<“不是合法的输入”< using namespace std;struct riqi { int year;int mon;int day;int hour;int minut;int second;};void main(){ riqi a;cout<<“输入时间日期”<>a.year;cout<<“输入月份”<

实验

三、函数的应用（2学时）

1、实验目的：

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

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

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

7)调试操作步骤如下：

选择菜单命令Build|Start Debug |Step In，系统进入单步执行状态，程序开始运行，并出现一个DOS窗口，此时光标停在main()函数的入口处。

把光标移到语句answer=fib(n)前，从Debug菜单单击Run To Cursor，在程序运行的DOS窗口中按提示输入数字10，这时回到可视界面中，光标停在第11行，观察一下n的值。

从Debug菜单中单击Step Into，程序进入fib函数，观察一下n的值，把光标移到语句return(fib(n-2)+fib(n-1))前，从Debug菜单单击Run to Cursor，再单击Step Into，程序递归调用fib函数，又进入fib函数，观察n的值。

继续执行程序，参照上述的方法，观察程序的执行顺序，加深对函数调用和递归调用的理解。

再试试Debug菜单栏中的别的菜单项，熟悉Debug的各种方法。

4、实验原理

C++中函数的重载使得同样的函数名下，只要参数类型、数目不同时，即可根据输入的数据进行相应的函数调用，使用起来简单方便。

5、思考与体会

C++中，函数的运用与之前学过的C语言既有相同之处，也有着不同的地方。相同的地方在于格式、用法等框架上的不变。但是C语言中对于同样的函数名是只能够申明一种函数的，倘若有相同的函数名出现系统即会报错，所以用起来有时是极为不便

0

//参数为两个双精度浮点形的函数 int max1(double a,double b){ a=a>b?a:b;return a;} //参数为三个双精度浮点形的函数 int max1(double a,double b,double c){ a=a>b?a:b;a=a>c?a:c;return a;} void main(void){ int a;double b;a=max1(1,2);cout<

Lab3_3: #include using namespace std;int max1(int a,int b){ a=a>b?a:b;return a;} int max1(int a,int b,int c){ a=a>b?a:b;a=a>c?a:c;return a;}

int main(){ int i,j,k;cout<<“请输入要比较的3个数：

”<

2131415

public: Rank rank;int frequency;float voltage;CPU(Rank r,int f,float v){

//构造函数

cout<<“构造了一个CPU”<

rank=r;

frequency=f;

voltage=v;} void run(){

cout<<“CPU开始运行”<

} void stop(){

cout<<“CPU停止运行”<

cout<<“RANK=”<

cout<<“frequency=”<

cout<<“voltage=”<

};

int main(){ CPU cpu(p5,500,2000);cpu.run();cpu.show();cpu.stop();return 0;}

Lab4_2 #include using namespace std;enum Rank{p1=1,p2,p3,p4,p5,p6,p7};//CPU类 class CPU{ public:

//析构函数-17

computer(Rank r,int f,float v){

CPU cpu(r,f,v);

//定义CPU对象

RAM ram(1);

//定义RAM对象

CDROM cdrom(1);

//定义CDROM对象

cpu.run();

cpu.show();

cpu.stop();} };int main(){ computer com(p4,300,3000);return 0;}

实验

七、继承与派生（一、二)4学时

1、实验目的：

学习定义和使用类的继承关系，定义派生类。熟悉不同继承方式下对基类成员的访问控制。学习利用虚基类解决二义性问题

2、实验任务 a)定义一个基类Animal，有私有整型成员变量age,构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把age改为公有成员变量，还会有问题吗？编程试试看。b)定义一个基类BaseClass，有整型成员变量Number ,构造其派生类DerivedClass，观察构造函数和析构函数的执行情况。c)定义一个车(vehicle)基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类。自行车类有高度(height)等属性，汽车类有座位数(SeatNum)等属性。从bicycle和motorcar派生出摩托车(motorcycle)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle设置为虚基类，会有什么问题？编程试试看。

3、实验步骤

编写程序定义基类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改为公有成员变量后重新编译就可以了。程序名为：lab7_1.cpp

0

确方便我们编程。

6、部分参考代码

Lab7_1 #include using namespace std;

class Animal{

public: int age;};

class dog:public Animal{ public: int SetAge(int n){

age=n;

return age;} };

void main(void){ int age;dog d;age=d.SetAge(3);cout<<“age=”<

Lab7_2 #include using namespace std;class BaseClass{ public: int Number;BaseClass(){

cout<<“这是父类的构造函数”<

cout<<“这是父类的析构函数”<

//Motorcycle继承bicycle和motorcar类

class motorcycle:public bicycle,public motorcar{ public: motorcycle(int seat,double H,double MS,double W){

SeatNum=seat;

height=H;

MaxSpeed=MS;

Weight=W;} void show(){

cout<<“seatnum=”<

cout<<“height=”<

cout<<“MaxSpeed=”<

cout<<“weight=”<

int main(){ motorcycle che(3,30.33,90.84,500);che.show();return 0;} 实验

八、多态性2学时

1、实验目的：

掌握运算符重载的方法

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

2、实验任务

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

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

3、实验步骤

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

也就是函数的重载。

6、部分参考代码

Lab8_1 #include using namespace std;

class Point{ public: Point(double x=0.0,double y=0.0):xray(x),yray(y){} Point operator++(int);Point operator--(int);void show();private: double xray;double yray;};

Point Point::operator++(int){ return Point(xray++,yray++);}

Point Point::operator--(int){ return Point(xray--,yray--);}

void Point::show(){ cout<<“x坐标为”<

int main(){ Point p(4.5,6.5);cout<<“进行运算前的情况：”<

show(&v);return 0;}

第五篇：上机实验报告格式

请各位同学按照下列格式写：否则按照0分记

上机实验报告格式

Matlab学习第？次上机实验报告（第？次）

姓名：？？？班级:???上机时间：？？？？？？

1.上机内容

2.建模及算法分析

3.程序

4.小结

5.参考文献

将文档发到我的邮箱里面

learn_matlab@163.com