实验6 继承与派生

c 继承与派生实验报告
C 继承与派生实验报告
实验目的：通过实验，掌握C语言中继承与派生的概念和使用方法，加深对面向对象编程的理解。

实验内容：在C语言中，继承与派生是面向对象编程中非常重要的概念。

在本次实验中，我们将通过一个简单的例子来演示C语言中的继承与派生的用法。

首先，我们定义一个基类（父类）Person，包括姓名和年龄两个成员变量，以及一个显示信息的成员函数。

然后，我们定义一个派生类（子类）Student，继承自Person类，新增一个成员变量学号，并重写显示信息的成员函数。

在实验中，我们首先创建一个Person对象，设置姓名和年龄，然后调用显示信息函数，观察结果。

接着，我们创建一个Student对象，设置姓名、年龄和学号，再次调用显示信息函数，观察结果。

实验结果：通过实验，我们成功实现了C语言中的继承与派生。

我们发现，通过继承，子类Student可以直接使用父类Person中的成员变量和成员函数，同时可以新增自己的成员变量和函数。

这样的设计使得代码更加简洁和灵活，提高了代码的复用性和可维护性。

结论：C语言中的继承与派生是面向对象编程中非常重要的概念，通过本次实验，我们深入理解了这一概念的用法和意义。

掌握了继承与派生的方法后，我们可以更加灵活地设计和编写程序，提高代码的质量和效率。

总结：通过本次实验，我们对C语言中的继承与派生有了更深入的理解，加深了对面向对象编程的认识。

在今后的学习和工作中，我们将更加灵活地运用继承与派生的方法，提高代码的质量和效率。

实验6 继承与派生实验时间：2012年10月18日，星期四，3、4节地点：5428实验目的（1）了解继承在面向对象程序设计中的重要作用（2）进一步理解继承与派生的概念（3）掌握通过继承派生出一个新类的方法（4）了解虚基类的作业和用法主要仪器设备电脑一台，安装Visual C++ 6.0实验内容分别声明Teacher（教师）类和Cadre（干部）类，采用多重继承方式由这两个类派生出新类Teacher_Cadre(教师兼干部)。

要求：（1）在两个基类中都包含姓名、年龄、性别、地址、电话等数据成员。

（2）在Teacher类中还包含数据成员title（职称），在Cadre类中还包含数据成员post（职务）。

在Teacher_Cadre类中包含数据成员wages(工资)。

（3）对两个基类中的姓名、年龄、性别、地址、电话等数据成员用相同的名字，在引用这些数据成员时，指定作用域。

（4）在类体中声明成员函数，在类外定义成员函数。

（5）在派生类Teacher_Cadre的成员函数show中调用Teacher类中的display 函数，输出姓名、年龄、性别、职称、地址、电话，然后再用cout语句输出职务与工资。

参考代码#include<string>#include <iostream>using namespace std;class Teacher{public:Teacher(string nam,int a,char s,string tit,string ad,string t);void display();protected:string name;int age;char sex;string title;string addr;string tel;};Teacher::Teacher(string nam,int a,char s,string tit,string ad,string t): name(nam),age(a),sex(s),title(tit),addr(ad),tel(t){ }void Teacher::display(){cout<<"name:"<<name<<endl;cout<<"age"<<age<<endl;cout<<"sex:"<<sex<<endl;cout<<"title:"<<title<<endl;cout<<"address:"<<addr<<endl;cout<<"tel:"<<tel<<endl;}class Cadre{public:Cadre(string nam,int a,char s,string p,string ad,string t);void display();protected:string name;int age;char sex;string post;string addr;string tel;};Cadre::Cadre(string nam,int a,char s,string p,string ad,string t):name(nam),age(a),sex(s),post(p),addr(ad),tel(t){}void Cadre::display(){cout<<"name:"<<name<<endl;cout<<"age:"<<age<<endl;cout<<"sex:"<<sex<<endl;cout<<"post:"<<post<<endl;cout<<"address:"<<addr<<endl;cout<<"tel:"<<tel<<endl;}class Teacher_Cadre:public Teacher,public Cadre{public:Teacher_Cadre(string nam,int a,char s,string tit,string p,string ad,string t,float w);void show( );private:float wage;};Teacher_Cadre::Teacher_Cadre(string nam,int a,char s,string t,string p,string ad,string tel,float w):Teacher(nam,a,s,t,ad,tel),Cadre(nam,a,s,p,ad,tel),wage(w) {}void Teacher_Cadre::show( ){Teacher::display();cout<<"post:"<<Cadre::post<<endl;cout<<"wages:"<<wage<<endl;}int main( ){Teacher_Cadre te_ca("Wang-li",50,'f',"prof.","president","135 Beijing Road,Shanghai","(021)61234567",1534.5);te_ca.show( );return 0;}。

继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1 {public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。

实验项目：继承与派生实验目的：1.学习定义和使用类的继承关系，定义派生类2.熟悉不同继承方式下对基类成员的访问控制实验任务：1.定义一个基类Animal，有私有整形成员变量age，构造其派生类dog，在其成员函数SetAge（int n）中直接给age赋值，看看会有什么问题，把age改为公有成员变量，还会有问题吗2.定义一个基类BaseClass，有整形成员变量Number，构造其派生类，观察其构造函数和析构函数的执行情况。

3.定义一个车类（vehicle）基类，有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车（bicycle）类、汽车（motorcar）类。

自行车（bicycle）类有高度（Height）等属性，汽车（motorcar）类有座位数（Seatnum）等属性。

，在继承和过程中，注意把vehicle设置为虚基类。

如果不把vehicle设置为虚基类，会有什么问题变成试试看。

实验步骤：1.编写程序定义Animal，成员变量age定义为私有的。

构造其派生类dog，在其成员函数SetAge（int n）中直接对age赋值时，会出现错误提示：程序名lab5_1.cpp2.编写程序定义一个基类BaseClass，构造其派生类DerivedClass，在构造函数和析构函数中用cout输出提示信息，观察构造函数和析构函数的执行情况。

程序名lab5_2.cpp3.用debug功能跟踪程序lab5_2.cpp的执行过程，观察基类和派生类的构造函数和析构函数的的执行过程。

4.编写程序定义车类（vehicle），由此派生出自行车（bicycle）类、汽车（motorcar），把vehicle设置为虚基类。

再从bicycle和motorcar派生出摩托车（motorcycle）类，在main（）函数中测试这个类。

程序名lab5_3.cpp。

编译成功后把vehicle设置成非虚基类，在编译一次，此时系统报错，无法编译成功。

实验6 继承与派生一、实验目的1．理解继承与派生、单继承与多继承的概念；2．理解基类与派生类的定义及使用方法，派生类对象的定义与初始化方法；3．理解继承与派生过程中，把派生类作为基类构成类族的概念及虚基类的概念。

二、实验环境一台PC机，Windows XP操作系统，Visual C++ 6.0开发环境。

三、实验内容1、由在校人员类(Person)作为基类派生出学生类(Student)：实验步骤：#include <iostream>#include <string>using namespace std;class Person{public:Person(int i,char *n, char s, int a){ID=i;name=n;sex=s;age=a;};int getID(){return ID;}void show(){cout<<"ID: "<<ID<<endl;cout<<"name : "<<name<<endl;cout<<"sex: "<<sex<<endl;cout<<"age: "<<age<<endl;}private:int ID;string name;char sex;int age;};class Student:public Person{public:Student(int i,char *n,char s,int a,float m,float p,float e,float c):Person(i,n,s,a){math=m;physical=p;english=e;cpp=c;total=math+physical+english+cpp;}void show(){Person::show();cout<<"math: "<<math<<endl;cout<<"physical: "<<physical<<endl;cout<<"english: "<<english<<endl;cout<<"C++: "<<cpp<<endl;cout<<"total: "<<total<<endl;}private:float math,physical,english,cpp,total;};void main(){Person p1(1,"张帅",'M',22);p1.show();cout<<endl;Student s1(9901,"林维",'S',21,65,70,75,88);s1.show();}实验结果：2、由学生类、课程类作为基类，共同派生出选课类。

课前讲解—类的继承与派生一、继承原理这里举一个继承的例子，定义两个类Point类，代表一个点；Rectangle类，代表一个矩形。

这里Point类（x,y）代表一个点的坐标，把它作为父类；Rectangle类，把它作为Point类的子类。

为啥这样考虑呢？因为一个点的位置决定了以后，就可以以这个点作为矩形的左上角坐标，然后再加上矩形的宽度，高度两个分量值，就可以直接构成一个矩形了。

我们可以看到，左边是Point类包含的所有属性和方法；右边则是Rectangle类包含的所有属性和方法，它的一部分属性和方法是从父类继承下来的。

任何一个矩形对象，都必须需要知道左上角的坐标位置（x,y）和其宽度w，高度h才能知道这是一个怎样的矩形。

因此每当我们用语句创建一个矩形对象的时候，需要调用initRectangle函数做矩形的初始化工作，要为这个函数传入四个参数：所传入的参数需要赋给对象的x,y,w,h分量。

由于在Rectangle类中只定义了宽度w，高度h两个属性，因此x,y的初始化工作它并不能直接完成，此时，就需要调用父类（Point类）里面的initPoint(x,y)函数来完成x,y分量的初始化，等父类的初始化工作完成后，然后再回到子类（Rectangle类）中完成w，h分量的初始化。

总结：Point类是父类，派生出Rectangle子类。

父类中定义的属性x，y被子类继承，子类中则增加了新的属性w,h。

二、派生类的构造函数和析构函数上述程序不是太好，如果引入构造函数和析构函数的概念，把上述的init函数改成构造函数，则代码会更好一些：经过上述定义后，每当创建Rectangle对象时，系统就会分配一块内存给这个对象：总共需要4个int空间，这四个数据成员都需要正确的赋予数值，才能定义一个有意义的矩形。

其中w,h两个属性是Rectangle对象可以直接访问的，而x,y两个属性继承自Point，而且是private，因此在Rectangle对象中不能直接访问这两个属性，只能通过间接调用getX(),getY()函数获取 x,y属性的值。

继承与派生实验报告继承与派生实验报告引言：继承与派生是面向对象编程中的重要概念，通过继承，一个类可以派生出子类，从而实现代码的复用和扩展。

本文将通过实验来探讨继承与派生的概念、原理和应用。

实验目的：1. 理解继承与派生的概念和原理；2. 掌握如何在编程语言中实现继承和派生；3. 熟悉继承与派生的应用场景。

实验步骤：1. 创建父类：首先，我们创建一个名为"Animal"的父类，该类具有属性和方法，例如"age"和"eat()"。

2. 创建子类：接下来，我们创建一个名为"Cat"的子类，该类继承自"Animal"类。

在子类中，我们可以重写父类的方法或添加新的方法。

3. 实例化对象：通过实例化父类和子类的对象，我们可以调用它们的方法和访问它们的属性。

4. 测试继承与派生：我们可以通过调用父类和子类的方法，观察它们的行为是否符合预期。

实验结果：在创建父类"Animal"时，我们定义了一个"age"属性和一个"eat()"方法。

在创建子类"Cat"时，我们继承了父类的属性和方法，并添加了一个新的"meow()"方法。

在实例化父类对象时，我们可以通过调用"eat()"方法来模拟动物进食的行为。

而在实例化子类对象时，我们既可以调用从父类继承而来的"eat()"方法，也可以调用子类特有的"meow()"方法来模拟猫咪的叫声。

通过实验，我们发现继承与派生的优势在于代码的复用和扩展。

我们只需在父类中定义一次通用的属性和方法，然后让不同的子类继承父类，即可实现代码的复用。

同时，子类还可以通过重写父类的方法或添加新的方法，实现代码的扩展和个性化。

讨论与应用：继承与派生不仅仅局限于上述的父类和子类关系，它还可以在多层次的继承结构中发挥作用。

实验六-继承与派生继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}voiddisplay(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;} private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;} void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;} };int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;} private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){ cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<e ndl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl; }};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1 {public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1 {public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。

继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}voiddisplay(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;} };int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;} private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f() <<endl; }~B(){cout<<"destructor B..."<<endl;} };class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。

实验六继承与派生（1）1.1 实验目的（1）理解继承的含义以及声明；（2）理解共有派生、私有派生和保护派生的含义以及使用；（3）理解单派生类中构造函数和析构函数的调用顺序。

1.2 实验内容1、定义点CPoint类作为基类，在此基础上派生出直线CLine类和圆CCircle类，并要求基类和各派生类具有以下特点：（1）CLine类含有计算直线长度和斜率的成员函数；（2）CCircle类含有计算圆面积的成员函数。

2、程序阅读。

（1）以下程序有两大错误，请修改程序，写出程序运行结果并分析。

#include <iostream>using namespace std;class CBase{public:CBase(int a):a(a){}protected:void print(){cout<<"a="<<a<<endl;}private:int a;};class CDerive : public CBasepublic:void print(){CBase::print();cout<<"b="<<b<<endl;}private:int b;};int main(){CDerive d;d.print();CBase b;b.print();return 0;}（2）分析基类和派生类的构造和析构顺序。

#include <iostream>using namespace std;class CBase{public:CBase(int a):a(a){cout<<"base structure"<<endl;}~CBase(){cout<<"base destructure"<<endl;}void print(){cout<<"a="<<a<<endl;}protected:int a;};class CDerive : public CBase{public:CDerive(int a, int b,int c):CBase(a),b(b),c(c){cout<<"derive structure"<<endl;}~CDerive(){cout<<"derive destructure"<<endl;}void print(){CBase::print();cout<<"b.a="<<b.a<<endl;cout<<"c="<<c<<endl;}private:CBase b;int c;};int main(){CDerive d(1,2,3); -----------------------------------------------------①d.print();return 0;}1.3 实验报告要求1．包含源程序和程序运行结果截图。

继承与组合令狐文艳一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;} void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl;}~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。

C 继承与派生实验报告1. 引言继承与派生是面向对象编程中的基本概念之一，C语言作为一门面向过程的编程语言，也支持继承与派生的概念。

本实验旨在通过编写代码演示C语言中的继承与派生的使用方法，加深对这一概念的理解。

2. 继承与派生的概念继承是一种面向对象编程中的重要概念，通过继承，派生类可以继承基类的属性和方法。

在C语言中，继承是通过结构体嵌套的方式实现的。

派生是继承的一种特殊形式，通过派生，派生类可以在基类的基础上增加新的属性和方法。

3. 实验步骤步骤一：定义基类首先，我们需要定义一个基类，基类包含一些公共的属性和方法。

在C语言中，我们可以使用结构体来定义类。

typedef struct {int x;int y;} Point;上述代码定义了一个名为Point的结构体，它包含了两个整型属性x和y。

这个结构体可以看作是基类。

步骤二：定义派生类接下来，我们可以定义派生类，派生类通过嵌套包含基类的结构体来实现继承。

typedef struct {Point base; // 基类结构体int z; // 派生类自己的属性} Point3D;上述代码定义了一个名为Point3D的结构体，它嵌套包含了基类Point的结构体，并新增了一个整型属性z。

这个结构体可以看作是派生类。

步骤三：使用派生类在定义好派生类后，我们可以使用派生类来创建对象，并调用基类的属性和方法。

int main() {// 创建对象Point3D point3d;point3d.base.x = 1;point3d.base.y = 2;point3d.z = 3;// 调用基类属性printf("x: %d\n", point3d.base.x);printf("y: %d\n", point3d.base.y);// 调用派生类自己的属性printf("z: %d\n", point3d.z);return0;}上述代码示例了如何使用派生类创建对象，并访问基类的属性和派生类自己的属性。

继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl;}int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"Dconstructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;} };int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:{cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。

实验6 继承与派生一、实验目的1．理解继承的含义，掌握派生类的定义和实现方法。

2．理解公有继承下基类成员对派生类成员和派生类对象的可见性，能正确地使用继承层次中的各种类成员。

3．理解保护成员在继承中的作用，能够在适当的时候使用保护成员以便派生类成员可以访问基类的部分非公开成员。

4．理解虚基类在类的继承层次中的作用，虚基类的引入对程序运行时的影响，能够对使用虚基类的简单程序写出程序结果。

二、知识要点1.继承继承是C++语言的一种重要机制，它允许在已定义的类的基础上产生新类。

从已定义类产生新类的过程称为派生。

已存在的用来派生新类的类为基类，又称父类。

从已存在的类派生出的新类称为派生类，又称为子类。

如，从哺乳动物类派生出狗类，哺乳动物是父类，狗是子类；从汽车类派生出轿车类，汽车是父类，轿车是子类。

在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。

从一个基类派生的继承称为单继承，从多个基类派生的继承称为多继承。

2.派生类的定义格式（1）单继承的定义格式class<派生类名>:<继承方式><基类名>{<派生类新定义成员>};其中：基类名是已经定义类的名称。

派生类名是新定义的一个类的名字，它是从基类中派生的；派生类是按指定继承方式从基类派生的，继承方式常用的有如下3种：public 表示公有继承private 表示私有继承protected 表示保护继承在单继承中，每个类可以有多个派生类，但是每个派生类只能有一个基类，从而形成树形结构。

（2）多继承的定义格式class<派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,……{<派生类新定义成员>};其中继承方式1、继承方式2、……是3种继承方式public、private和protected之一。

多继承与单继承的主要区别从定义格式上看，主要是多继承的基类多于一个。

C 继承与派生实验报告C 继承与派生实验报告引言：在计算机编程领域，继承与派生是一种重要的概念。

通过继承，我们可以构建更加复杂和灵活的程序结构，提高代码的可重用性和可维护性。

本实验旨在通过实际操作和分析，深入理解C语言中继承与派生的原理和应用。

实验目的：1. 理解继承与派生的概念和原理；2. 掌握C语言中继承与派生的语法和用法；3. 实践继承与派生的应用，加深对其理解。

实验步骤：1. 创建基类和派生类：首先，我们创建一个基类Animal，其中包含一个成员函数eat()和一个成员变量name。

然后，我们创建一个派生类Dog，继承自基类Animal，并添加一个成员函数bark()和一个成员变量breed。

2. 实现继承与派生的功能：在基类Animal中，实现成员函数eat()，用于输出动物的进食行为。

在派生类Dog中，实现成员函数bark()，用于输出狗的吠叫行为。

同时，通过继承，派生类Dog可以直接访问基类Animal中的成员变量name。

3. 测试继承与派生的效果：在主函数中，创建一个Dog对象，并调用其成员函数eat()和bark()，以验证继承与派生的功能是否正常工作。

同时，可以通过修改派生类Dog的成员变量breed，观察其对程序运行结果的影响。

实验结果与分析：通过实验，我们可以发现继承与派生的强大功能。

基类Animal提供了一种通用的行为eat()，而派生类Dog则通过添加成员函数bark()，实现了更加具体和特定的行为。

这种继承与派生的关系，使得我们可以在保留原有功能的基础上，进行灵活的扩展和定制。

此外，通过继承，派生类Dog可以直接访问基类Animal中的成员变量name。

这种继承的特性，使得派生类可以共享基类的数据，避免了重复定义和冗余代码的问题。

同时，通过修改派生类Dog的成员变量breed，我们可以看到其对程序运行结果的影响。

这种灵活性，使得我们可以根据具体需求，定制不同的派生类，实现更加个性化的功能。

继承与组合欧阳家百（2021.03.07）一、实验目的1．了解继承在面向对象程序设计中的重要作用。

2．进一步理解继承与派生的概念。

3．掌握通过继承派生出一个新的类的方法。

4．了解虚基类的作用和用法。

5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。