实验2继承与派生讲解
- 格式:doc
- 大小:204.51 KB
- 文档页数:8
c 继承与派生实验报告
C 继承与派生实验报告
实验目的:通过实验,掌握C语言中继承与派生的概念和使用方法,加深对面向对象编程的理解。
实验内容:在C语言中,继承与派生是面向对象编程中非常重要的概念。
在本次实验中,我们将通过一个简单的例子来演示C语言中的继承与派生的用法。
首先,我们定义一个基类(父类)Person,包括姓名和年龄两个成员变量,以及一个显示信息的成员函数。
然后,我们定义一个派生类(子类)Student,继承自Person类,新增一个成员变量学号,并重写显示信息的成员函数。
在实验中,我们首先创建一个Person对象,设置姓名和年龄,然后调用显示信息函数,观察结果。
接着,我们创建一个Student对象,设置姓名、年龄和学号,再次调用显示信息函数,观察结果。
实验结果:通过实验,我们成功实现了C语言中的继承与派生。
我们发现,通过继承,子类Student可以直接使用父类Person中的成员变量和成员函数,同时可以新增自己的成员变量和函数。
这样的设计使得代码更加简洁和灵活,提高了代码的复用性和可维护性。
结论:C语言中的继承与派生是面向对象编程中非常重要的概念,通过本次实验,我们深入理解了这一概念的用法和意义。
掌握了继承与派生的方法后,我们可以更加灵活地设计和编写程序,提高代码的质量和效率。
总结:通过本次实验,我们对C语言中的继承与派生有了更深入的理解,加深了对面向对象编程的认识。
在今后的学习和工作中,我们将更加灵活地运用继承与派生的方法,提高代码的质量和效率。
C 继承与派生实验报告C 继承与派生实验报告引言:在面向对象的编程中,继承与派生是重要的概念。
通过继承,我们可以从已有的类中派生出新的类,并且可以在新的类中添加额外的属性和方法。
本实验旨在通过实际的编程实践,深入理解C语言中的继承与派生。
实验过程:首先,我们创建了一个基类Animal,其中包含了一个成员变量name和一个成员函数eat。
然后,我们创建了两个派生类Dog和Cat,它们分别继承了Animal类,并且在其中添加了各自特有的成员函数bark和meow。
接着,我们创建了一个对象dog和一个对象cat,并分别调用了它们的成员函数eat、bark 和meow。
实验结果:通过运行程序,我们可以看到dog对象调用了eat和bark函数,而cat对象调用了eat和meow函数。
这说明继承与派生的机制正常工作,派生类可以继承基类的属性和方法,并且可以在派生类中添加新的属性和方法。
实验分析:继承与派生是面向对象编程的重要概念,它可以使得代码的复用性更高,同时也增加了代码的灵活性。
通过继承,派生类可以继承基类的属性和方法,这样可以减少代码的冗余,并且可以在派生类中添加新的功能。
在本实验中,Dog 和Cat类分别继承了Animal类,这样它们就拥有了相同的属性name和方法eat。
然后,通过在派生类中添加新的方法bark和meow,我们可以实现不同的行为。
继承与派生的应用:继承与派生在实际的软件开发中有着广泛的应用。
例如,在一个图形界面程序中,可以定义一个基类Widget,它包含了一些基本的属性和方法,然后可以通过派生类Button和TextBox来创建具体的按钮和文本框。
这样,我们可以通过继承和派生的方式,实现不同的界面元素,并且可以在派生类中添加新的功能,如按钮的点击事件和文本框的输入验证。
继承与派生的注意事项:在使用继承与派生的过程中,我们需要注意一些问题。
首先,派生类可以访问基类的公有成员,但不能访问基类的私有成员。
实验2 继承与派生2.1 实验目的1.熟练掌握类的继承,能够定义和使用类的继承关系。
2.掌握派生类的声明与实现方法。
3.掌握类构造函数的初始化列表与作用域分辨符的使用方法。
4.理解虚基类在解决二义性问题中的作用。
2.2 实验工具与准备工作在开始实验前,应回顾或复习相关内容。
需要一台主算机,其中安装有Visual C++ 6.0等集成开发环境软件。
2.3 实验内容1.先阅读下列程序,写出执行结果。
然后输入程序,调试程序,比较结果的正确性。
// 文件名: main.cpp#include <iostream> // 预处理命令using namespace std; // 使用标准命名空间stdclass A{public:// 公有函数:A(){ cout << "构造A" << endl; } // 构造函数~A(){ cout << "析构A" << endl; } // 析构函数};class B: public A{public:// 公有函数:B(){ cout << "构造B" << endl; } // 构造函数~B(){ cout << "析构B" << endl; } // 析构函数};class C: public B{public:// 公有函数:C(){ cout << "构造C" << endl; } // 构造函数~C(){ cout << "析构C" << endl; } // 析构函数};int main(void) // 主函数main(void){C obj; // 定义对象system("PAUSE"); // 调用库函数system( ),输出系统提示信息return 0; // 返回值0, 返回操作系统}2.先阅读下列程序,写出执行结果。
实验二类的继承和派生1.实验目的(1)掌握利用单继承和多继承的方式定义派生类的方法。
(2)深刻理解在各种继承方式下构造函数和析构函数的执行顺序。
(3)理解和掌握公有继承、私有继承和保护继承对基类成员的访问机制。
(4)理解虚基类的目的和作用。
2.实验内容(1)声明一个圆类作为基类,含成员数据半径R;有成员函数:构造函数实现对基类成员数据的初始化、计算圆面积的成员函数、输出的成员函数,要求输出圆半径R。
把圆类作为基类,通过公有继承,派生圆柱体类,派生类新增成员数据有高(H);新增成员函数有构造函数、计算圆柱体体积的函数、输出所有成员的函数。
main()完成派生类对象的定义和相关函数的测试。
(2)声明一个学生类,有成员函数:学号、姓名、性别、年龄,要求有如下成员函数:构造函数,输出所有成员的函数。
声明一个课程类,有成员数据:课程编号、课程名称、学时数,要求有如下成员函数:构造函数,输出所有成员的函数。
将学生类和课程类作为基类,通过公有继承,派生选课类,派生类新增成员数据有:成绩;新增成员函数有:构造函数,输出所有成员的函数。
main()完成派生类对象的定义和相关函数的测试。
(3)设计一个汽车类Vehicle,包含数据成员车轮和重量,由它派生出类Car 和类Truck,前者包含载客数,后者包含载重量。
编写程序实现。
3.实验要求(1)独立完成实验。
(2)实验前需先预先浏览实验指导书,编好源程序。
(3)实验过程中尽量独立思考,培养分析问题和解决问题的能力。
(4)实验完毕后书写实验报告,实验报告内容包括:实验内容、结果分析以及本次实验的心得体会。
要求将程序源代码和运行时的输入输出数据情况书写在实验内容部分,并对程序的输出结果进行分析,说明为什么能得出相应的结果(如果不能输出预期结果,需要分析说明其原因)。
实验项目:继承与派生实验目的: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设置成非虚基类,在编译一次,此时系统报错,无法编译成功。
实验二类的继承与派生实验二类的继承与派生一、实验目的1. 掌握类的声明和使用。
2. 掌握对象的声明和使用。
3. 掌握具有不同访问属性的成员的访问方式。
4. 观察构造函数和析构函数的执行过程。
5. 学习声明和使用类的继承关系,声明派生类;6. 熟悉不同继承方式下对基类成员的访问控制;二.实验内容1. 设计一个用于人事管理的People(人员)类。
考虑到通用性,这里只抽象出所有类型人员都具有的属性:number(编号)、sex (性别)、birthday(出生日期)、id(身份证号)等等。
具有的属性如下:姓名char name[11]、编号char number[7]、性别char sex[3]、生日birthday、身份证号charid[20]。
其中“出生日期”声明为一个“日期”类内嵌子对象。
用成员函数实现对人员信息的录入和显示。
要求包括:构造函数和析构函数、拷贝构造函数、内联成员函数、组合。
在测试程序中声明people 类的对象数组,录入数据并显示。
2. 从people(人员)类派生出student(学生)类,添加属性:班号char classNO[7];从people 类派生出teacher(教师)类,添加属性:职务char pship[11]、部门char departt[21]。
从student 类中派生出graduate(研究生)类,添加属性:专业char subject[21]、导师teacher adviser;从graduate 类和teacher 类派生出TA(助教博士生)类,重载相应的成员函数,测试这些类。
三 . 实验步骤1.程序代码第一题#include#includeusing namespace std;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<<"日";< bdsfid="103" p=""></year<<"年"<<month<<"月"<<day<<"日";<>}};class Person //人员类{private:string name;int num;char sex;Date birthday;char ID[18];public:Person(){} //默认构造Person(int n,int y,int m,int d,char id[18],char s='m'):birthday(y,m,d) {num=n;sex=s;strcpy(ID,id);} //有默认值的带参构造Person(Person& p) //拷贝构造{ name=;num=p.num;sex=p.sex;birthday=p.birthday;strcpy(ID,p.ID);}void input() //输入函数{cout<<"录入数据:"<<endl;< bdsfid="131" p=""></endl;<> cout<<"姓名:";cin>>name;cout<<"编号:";cin>>num;cout<<"性别(m/f):";cin>>sex;cout<<"生日:";birthday.set();cout<<"身份证号:";cin>>ID;ID[18]='\0';cout<<endl;< bdsfid="144" p=""></endl;<>}void output() //输出函数{cout<<"编号:"<<num<<endl;< bdsfid="149" p=""></num<<endl;<>cout<<"姓名:"<<name<<endl;< bdsfid="151" p=""></name<<endl;<>cout<<"性别:"<<sex<<endl;< bdsfid="153" p=""></sex<<endl;<>cout<<"生日:";birthday.display();cout<<endl;< bdsfid="157" p=""></endl;<>cout<<"身份证号:"<<id<<endl;< bdsfid="159" p=""></id<<endl;<>}~Person() //析构函数{cout<<" "<<num<<"号人员已经录入"<<=""></num<<"号人员已经录入"<};int main(){Person p1;p1.input();p1.output();return 0;}第二题#include#includeusing namespace std;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<<"日";< bdsfid="200" p=""></year<<"年"<<month<<"月"<<day<<"日";<>}};class Person //人员类{private:string name;int num;char sex[10];Date birthday;char ID[18];public:Person(){} //默认构造Person(int n,int y,int m,int d,char id[18],char sex[10]):birthday(y,m,d) {num=n;strcpy(ID,id);} //有默认值的带参构造Person(Person& p) //拷贝构造{ name=;num=p.num;birthday=p.birthday;strcpy(ID,p.ID);}void input() //输入函数{cout<<"姓名:";cin>>name;cout<<"编号:";cin>>num;cout<<"性别(男/女):";cin>>sex;cout<<"生日:";birthday.set();cout<<"身份证号:";cin>>ID;ID[18]='\0';cout<<endl;< bdsfid="237" p=""></endl;<>}void output() //输出函数{cout<<"编号:"<<num<<endl;< bdsfid="242" p=""></num<<endl;<>cout<<"姓名:"<<name<<endl;< bdsfid="244" p=""></name<<endl;<>cout<<"性别:"<<sex<<endl;< bdsfid="246" p=""></sex<<endl;<>cout<<"生日:";birthday.display();cout<<endl;< bdsfid="250" p=""></endl;<>cout<<"身份证号:"<<id<<endl;< bdsfid="252" p=""></id<<endl;<>}~Person() //析构函数{//cout<<" "<<num<<"号人员已经录入"<<=""></num<<"号人员已经录入"<};class stduent:public Person{char classno[7];public: student(){cout<<"*************"<<="">void input(){Person::input();cout<<"输入学号"<<endl;< bdsfid="269" p=""></endl;<>cin>>classno;}void getno(){Person::output();cout<<"学号为:"<<classno<<endl;< bdsfid="275" p=""></classno<<endl;<>}};class teacher:public Person{char pship[11],departt[21];public :teacher(){cout<<"***********"<<endl;}< bdsfid="283" p=""></endl;}<> void input(){Person::input();cout<<"输入职务"<<endl;< bdsfid="288" p=""></endl;<>cin>>pship;cout<<"输入部门"<<endl;< bdsfid="291" p=""></endl;<>cin>>departt;}void inputt(){cout<<"输入职务"<<endl;< bdsfid="297" p=""></endl;<>cin>>pship;cout<<"输入部门"<<endl;< bdsfid="300" p=""></endl;<>cin>>departt;}void getno(){Person::output();cout<<"职务为:"<<pship<<endl;< bdsfid="306" p=""></pship<<endl;<>cout<<"部门为:"<<departt<<endl;< bdsfid="308" p=""></departt<<endl;<>}void output (){cout<<"职务为:"<<pship<<endl;< bdsfid="313" p=""></pship<<endl;<>cout<<"部门为:"<<departt<<endl;< bdsfid="315" p=""></departt<<endl;<>}};class graduate:public stduent{char subject[21], adviser[21];public :graduate(){cout<<""<<endl;< bdsfid="323" p=""></endl;<>}void input(){stduent::input();cout<<"输入专业:"<<endl;< bdsfid="329" p=""></endl;<> cin>>subject;cout<<"输入导师:"<<endl;< bdsfid="332" p=""></endl;<>cin>>adviser;}void getno(){ stduent::getno();cout<<"专业为:"<<subject<<endl;< bdsfid="338" p=""></subject<<endl;<>cout<<"导师为:"<<adviser<<endl;< bdsfid="340" p=""></adviser<<endl;<>}};class TA :public graduate,teacher{public :TA(){}void input(){graduate::input();teacher::inputt();}void getno(){graduate::getno();teacher::output();}};int main(){Person p1;stduent s;teacher t;graduate g;TA T;cout<<"请依次输入人员数据信息"<<endl;< bdsfid="366" p=""></endl;<>p1.input();cout<<"请输入学生数据信息";s.input();cout<<"请输入老师数据信息";t.input();cout<<"请输入研究生数据信息";g.input();cout<<"请输入助教博士数据信息";T.input();cout<<"人员数据信息为:";p1.output();cout<<"学生数据信息为:";s.getno();cout<<"老师信息为:";t.getno();cout<<"研究生信息为:";g.getno();cout<<"助教博士信息为:"T.getno();}2.调试程序第一次调试,发现没有名字的显示。
继承与派生实验报告继承与派生实验报告引言:继承与派生是面向对象编程中的重要概念,通过继承,一个类可以派生出子类,从而实现代码的复用和扩展。
本文将通过实验来探讨继承与派生的概念、原理和应用。
实验目的:1. 理解继承与派生的概念和原理;2. 掌握如何在编程语言中实现继承和派生;3. 熟悉继承与派生的应用场景。
实验步骤:1. 创建父类:首先,我们创建一个名为"Animal"的父类,该类具有属性和方法,例如"age"和"eat()"。
2. 创建子类:接下来,我们创建一个名为"Cat"的子类,该类继承自"Animal"类。
在子类中,我们可以重写父类的方法或添加新的方法。
3. 实例化对象:通过实例化父类和子类的对象,我们可以调用它们的方法和访问它们的属性。
4. 测试继承与派生:我们可以通过调用父类和子类的方法,观察它们的行为是否符合预期。
实验结果:在创建父类"Animal"时,我们定义了一个"age"属性和一个"eat()"方法。
在创建子类"Cat"时,我们继承了父类的属性和方法,并添加了一个新的"meow()"方法。
在实例化父类对象时,我们可以通过调用"eat()"方法来模拟动物进食的行为。
而在实例化子类对象时,我们既可以调用从父类继承而来的"eat()"方法,也可以调用子类特有的"meow()"方法来模拟猫咪的叫声。
通过实验,我们发现继承与派生的优势在于代码的复用和扩展。
我们只需在父类中定义一次通用的属性和方法,然后让不同的子类继承父类,即可实现代码的复用。
同时,子类还可以通过重写父类的方法或添加新的方法,实现代码的扩展和个性化。
讨论与应用:继承与派生不仅仅局限于上述的父类和子类关系,它还可以在多层次的继承结构中发挥作用。
7.1 继承和派⽣考点1 继承和派⽣的基本概念 继承的实质就是建造新的派⽣类。
派⽣类从⼀个或多个以前定义的基类继承数据和函数,同时增加或重新定义数据和操作。
这就产⽣了类的层次性。
换句话说,继承就是创建⼀个具有别的类属性和⾏为的新类的能⼒。
我们把这种通过特殊化已有的类来建⽴新类的过程,叫做“类的派⽣”,原有的类叫做“基类”,新建⽴的类叫做“派⽣类”从类的成员⾓度来看,派⽣类⾃动地将基类的所有数据成员和除了构造,析构函数之外的全部成员函数作为⾃⼰的成员,这叫做“继承”。
基类和派⽣类⼜可以分别叫做“⽗类”和“⼦类”。
在C++中有两种继承:单继承和多继承。
对于单继承,派⽣类中只能有⼀个基类;对于多继承,派⽣类可以有多个基类。
单继承和多继承的基类和派⽣类的关考点2 派⽣类的定义与构成 在C++中,定义派⽣类的⼀般形式为: 单继承的定义如下: class<派⽣类名>:<继承⽅式><基类名>{<派⽣类新定义的成员>}; 多继承的定义如下: class<派⽣类名>:<继承⽅式1><基类名1>,<继承⽅式2><基类名2>, …<继承⽅式n><基类名n>{<派⽣类新定义的成员>}; 其中,<继承⽅式>即派⽣类的访问控制⽅式,⽤于规定基类成员在派⽣类中的访问权限,即基类成员在派⽣类中是公有的、私有的或保护的。
常⽤的3种继承⽅式是公有继承(public),私有继承(private)和保护继承(protected)。
缺省的类继承⽅式是私有继承private . <派⽣类新定义的成员>是指定义的派⽣类⾃⼰的成员(除了从基类继承来的所有成员之外,新增加的数据成员和函数成员)。
派⽣类的成员由两部分构成:⼀部分是从基类继承得到的,⼀部分是⾃⼰定义的新成员,所有这些成员仍然分为公有(public),私有(private)和保护(protected)3种访问性质。
派生与继承的关系,及派生应用中要注意的问题
派生(也称为继承)是面向对象编程中的一个重要概念,它允许一个类(派生类或子类)继承另一个类(基类或父类)的属性和方法。
派生与继承的关系如下:
1. 代码重用:通过继承,派生类可以复用基类的代码,减少代码重复。
2. 扩展性:派生类可以在继承基类的同时添加新的属性和方法,以实现更复杂的功能。
3. 多态性:通过继承,可以实现多态性,即父类指针或引用可以指向子类对象,调用子类的方法。
在派生应用中,需要注意以下几个问题:
1. 封装性:要确保基类的属性在派生类中仍然保持封装性,即不要在派生类中直接访问基类的私有属性。
2. 构造函数:如果基类有构造函数,派生类需要显式调用基类的构造函数,或者在派生类的构造函数中实现与基类构造函数相同的功能。
3. 虚函数和纯虚函数:如果基类中有虚函数或纯虚函数,派生类需要实现这些函数或者声明这些函数为纯虚函数。
4. 访问权限:要确保派生类中的成员函数能够访问基类的公有成员和保护成员,但不能访问基类的私有成员。
5. 覆盖和隐藏:如果基类和派生类中有同名函数,则派生类中的函数会覆盖基类中的函数(也称为重写)。
如果基类中的函数是公有或保护的,而派生类中的函数是私有的,则称为隐藏。
覆盖和隐藏可能会引起一些问题,需要注意区分和处理。
实验二运算符重载、继承和派生【实验目的】1、掌握继承的概念。
2、理解派生类与基类的关系。
3、理解不同的继承类型。
4、掌握继承下的构造函数和析构函数。
5、掌握单继承和多继承使用方法。
6、理解重载运算符的意义。
7、掌握用成员函数、友元函数重载运算符的特点。
8、掌握重载运算符函数的调用方法。
【实验内容】1、上机分析下面程序,掌握运算符重载的方法。
#include <iostream.h>class Complex{friend Complex operator+( const double &d, const Complex &c );friend Complex operator-( const double &d, const Complex &c );double m_fReal, m_fImag;public:Complex( const double &r = 0, const double &i = 0): m_fReal( r ), m_fImag( i ){}Complex( const Complex &c ): m_fReal( c.m_fReal ), m_fImag( c.m_fImag ){}double GetReal() const{return m_fReal;}double GetImag() const{return m_fImag;}Complex& operator=( const Complex &c ){if( this == &c ){return *this;}m_fReal=c.m_fReal;m_fImag=c.m_fImag;return *this;}Complex operator+( const Complex &c ){return Complex( m_fReal+c.m_fReal, m_fImag+c.m_fImag );}Complex operator-( const Complex &c ){return Complex( m_fReal-c.m_fReal, m_fImag-c.m_fImag );}Complex operator+( const double &d ){return Complex( m_fReal+d, m_fImag );}Complex operator-( const double &d ){return Complex( m_fReal-d, m_fImag );}};Complex operator+( const double &d, const Complex &c ){return Complex( d + c.m_fReal, c.m_fImag );}Complex operator-( const double &d, const Complex &c ){return Complex( d - c.m_fReal, c.m_fImag );}int main(){Complex c1( 3.3, 4.4 );Complex c2( 5.5, 2.2 );Complex c3;c3 = c1 + c2;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = c1 - c2;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = c1 + c2;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = c1 + 1.1;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = c1 - 1.1;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = 9.9 + c1;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;c3 = 9.9 - c1;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;( c3 = c1 ) = c2;cout << "C3 = " << c3.GetReal() << "+i" << c3.GetImag() << endl;return 0;}2、上机分析下面程序,理解继承的概念。
实验2 派生类与继承实验课程名:面向对象程序设计(C++)专业班级:学号:姓名:实验时间:实验地点:指导教师:二、实验内容一、构造一个类Geometry 及其派生类,该类主要实现关于几何图形的基本操作。
对于基类“几何图形”,有求面积、求体积的函数(纯虚函数),其派生类圆和矩形主要有初始化(构造函数),求面积,求周长操作,类圆的派生类圆球和圆柱有求表面积、体积操作。
试在主函数中分别定义圆、圆球、圆柱以及矩形的对象,并调用其成员函数实现其相应操作。
实验代码如下:#include<iostream>using namespace std;class Geometry{public:CircleradiumsCircle()~Circle() BallBall()~Ball() GeometryGeometry()~Geometry()GetArea()GetPerimeter()Getcolume()show()Column Column()~Column()Rectangle Rectangle() ~Rectangle()Column column(1,2,3);column.show();return 0;}运行结果:代码分析:1)首先定义基类Geometry,在定义基类的派生类Circle,Rectangle再定义以Circle,Rectangle为基类的派生类Column,以及以Circle为基类的派生类Ball;2)在定义派生类时用构造函数初始化私有成员;3)最后用类的对象来调用类函数;二、设计如下类:(1)建立一个Point类,表示平面中的一个点;建立一个Line类,表示平面中的一条线端,内含两个Point类的对象;建立Triangle类,表示一个三角形,内含三个Line类的对象构成一个三角形。
(2)设计三个类的相应的构造函数、复制构造函数,完成初始化和对象复制(3)设计Triangle类的成员函数完成三条边是否能构成三角形的检验和三角形面积计算,面积显示。
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;}上述代码示例了如何使用派生类创建对象,并访问基类的属性和派生类自己的属性。
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,我们可以看到其对程序运行结果的影响。
这种灵活性,使得我们可以根据具体需求,定制不同的派生类,实现更加个性化的功能。
实验4 继承与派生班级学号(最后两位)姓名成绩一、实验目的1.熟练掌握类的继承,能够定义和使用类的继承关系2.掌握派生类的声明与实现方法3.掌握类构造函数的初始化列表与作用域分辨率的使用方法4.理解虚基类在解决二义性问题中的作用.二、实验内容1.定义一个基类有姓名、性别、年龄,再由基类派生出教师类和学生类,教师类增加工号、职称和工资,学生类增加学号、班级、专业和入学成绩。
2.声明一个哺乳动物Mammal类,再由此派生出狗Dog类,声明一个Dog类的对象,观察基类与派生类的构造函数与析构函数的调用顺序。
3.定义一个Point类,派生出矩形类Rectangle和圆类Circle,计算各派生类对象的面积Area()。
4.设计一个圆类circle和一个桌子类table,另设计一个圆桌类roundtable,它是从前两个类派生的,要求输出一个圆桌的高度、面积和颜色等数据。
5.定义一个大学生类student,函数私有数据成员:姓名、学号、校名,并为它定义带参数的构造函数,参数带缺省值的构造函数和输出数据成员值的print()公有成员函数,另定义研究生类,它以公有继承方式派生于类student,新增加“研究方向、导师名”两个私有数据成员,并定义带参数的构造函数和输出研究生数据的print()公有成员函数。
在main()函数中定义基类和派生类对象,对类进行测试。
三、实验源程序、测试与结论1.#include<iostream>#include<string>using namespace std;class person{public:person(string name_,char sex_,int age_):name(name_),sex(sex_),age(age_){}void show(){cout<<"name: "<<name<<endl;cout<<"sex: "<<sex<<endl;cout<<"age: "<<age<<endl;}protected:string name;char sex;int age;};class teacher:public person{public:teacher(string name_,char sex_,int age_,int j_n,string job_,int wage_):person(name_,sex_,age_),job_number(j_n),job(job_),wage(wage_){}void show1();private:int job_number;string job;int wage;};void teacher::show1(){cout<<"This teacher is: "<<endl;show();cout<<"job number: "<<job_number<<endl;cout<<"job: "<<job<<endl;cout<<"wage: "<<wage<<endl;}class student:public person{public:student(string name_, char sex_, int age_, int num_, string cla_, string major_, int score_): person(name_,sex_,age_), num(num_), cla(cla_), major(major_), score(score_){}void show2();private:int num;string cla;string major;int score;};void student::show2(){cout<<"This student is: "<<endl;show();cout<<"NO: "<<num<<endl;cout<<"class: "<<cla<<endl;cout<<"major: "<<major<<endl;cout<<"score: "<<score<<endl;}void main(){teacher t("John",'M',28,11111,"math",5000);t.show1();student s("Randy",'M',20,1210034,"BX1205","electron",100);s.show2();}2.#include<iostream>using namespace std;class Mammal{public:Mammal(){cout<<"Constructor Mammal"<<endl;}~Mammal(){cout<<"Mammal will die"<<endl;}};class Dog:public Mammal{public:Dog():Mammal(){cout<<"Constructor Dog"<<endl;}~Dog(){cout<<"Dog will die"<<endl;}};void main(){Dog dog;}3.#include<iostream>#include<math.h>using namespace std;#define PI 3.14class Point{public:Point(float x_=0, float y_=0):x(x_),y(y_){} protected:float x;float y;};class Rectangle:public Point{public:Rectangle(float x_, float y_):Point(x_,y_){}void Area();};void Rectangle::Area(){float area;area=x*y;cout<<"矩形的面积为: "<<area<<endl; }class Circle:public Point{public:Circle(float r_):Point(),r(r_){}void Area();private:float r;};void Circle::Area(){float area;area=PI*r*r;cout<<"圆的面积为: "<<area<<endl; }void main(){float l,w,r;cout<<"请输入长方形的长和宽: ";cin>>l>>w;cout<<"请输入圆的半径: ";cin>>r;Rectangle rectangle(l,w);rectangle.Area();Circle circle(r);circle.Area();}4.#include<iostream>using namespace std;#include<string>#define PI 3.14class circle{public:circle(float r_=0):r(r_){}void Area(){float area;area=PI*r*r;cout<<"圆的面积为: "<<area<<endl;}protected:float r;};class table{public:table(float h_, string color_):h(h_),color(color_){}void show(){cout<<"桌子的高度: "<<h<<'\n'<<"桌子颜色: "<<color<<'\n';}protected:float h;string color;};class roundtable:public circle,public table{public:roundtable(float r_, float h_, string color_):circle(r_),table(h_,color_) {cout<<"这是一个圆桌,它具体属性有: "<<endl;}};void main(){float r, h;string color;cout<<"请输入圆的半径: ";cin>>r;cout<<"请输入桌子的高度和颜色: ";cin>>h>>color;roundtable t(r,h,color);t.show();t.Area();}5.#include<iostream>using namespace std;#include<string>class student{private:string name, school;int no;public:student(string name_,int no_,string school_):name(name_),no(no_),school(school_){} student(){name="John";no=121003400;school="Shanghai University";}void print(){cout<<"大学生的信息如下: "<<endl;cout<<"姓名: "<<name<<endl;cout<<"学号: "<<no<<endl;cout<<"校名: "<<school<<endl;}};class graduate:public student{private:string direction,teacher;public:graduate(string name_,int no_,string school_,string direction_,string teacher_):student(name_,no_,school_),direction(direction_),teacher(teacher_){}void print(){cout<<"研究生的信息如下: "<<endl;cout<<"研究方向: "<<direction<<endl;cout<<"导师: "<<teacher<<endl;}};void main(){student s1;s1.print();student s2("Ranen", 121003411, "SDJU");s2.print();graduate s3("Cachy",121003422, "SDJU","Math","Tom");s3.student::print();s3.print();}。
实验2 继承与派生2.1 实验目的1.熟练掌握类的继承,能够定义和使用类的继承关系。
2.掌握派生类的声明与实现方法。
3.掌握类构造函数的初始化列表与作用域分辨符的使用方法。
4.理解虚基类在解决二义性问题中的作用。
2.2 实验工具与准备工作在开始实验前,应回顾或复习相关内容。
需要一台主算机,其中安装有Visual C++ 6.0等集成开发环境软件。
2.3 实验内容1.先阅读下列程序,写出执行结果。
然后输入程序,调试程序,比较结果的正确性。
// 文件名: main.cpp#include <iostream> // 预处理命令using namespace std; // 使用标准命名空间stdclass A{public:// 公有函数:A(){ cout << "构造A" << endl; } // 构造函数~A(){ cout << "析构A" << endl; } // 析构函数};class B: public A{public:// 公有函数:B(){ cout << "构造B" << endl; } // 构造函数~B(){ cout << "析构B" << endl; } // 析构函数};class C: public B{public:// 公有函数:C(){ cout << "构造C" << endl; } // 构造函数~C(){ cout << "析构C" << endl; } // 析构函数};int main(void) // 主函数main(void){C obj; // 定义对象system("PAUSE"); // 调用库函数system( ),输出系统提示信息return 0; // 返回值0, 返回操作系统}2.先阅读下列程序,写出执行结果。
然后输入程序,调试程序,比较结果的正确性。
// 文件名: main.cpp#include <iostream> // 预处理命令using namespace std; // 使用标准命名空间stdclass A{protected:// 数据成员:int a; // 数据成员public:// 公有函数:A(int x): a(x){ } // 构造函数void Show() const{ cout << a << endl; } // 显示a之值};class B{protected:// 数据成员:int b; // 数据成员public:// 公有函数:B(int x): b(x){ } // 构造函数void Show() const{ cout << b << endl; } // 显示a与b之值};class C: public A, public B{public:// 公有函数:C(int x, int y): A(x), B(y){ } // 构造函数void Show() const // 显示b之值{ cout << a << "," << b << endl; }};int main(void) // 主函数main(void){C obj(5, 18); // 定义对象obj.Show(); // 显示相关信息obj.A::Show(); // 显示相关信息obj.B::Show(); // 显示相关信息system("PAUSE"); // 调用库函数system( ),输出系统提示信息return 0; // 返回值0, 返回操作系统}3.程序填空。
下面程序主要测试类构造函数的初始化列表与作用域分辨符,请完成程序。
// 文件名: main.cpp#include <iostream> // 预处理命令using namespace std; // 使用标准命名空间stdclass A{private:// 数据成员:int a; // 数据成员public:// 公有函数:A(int x): a(x) { } // 构造函数void Show() const // 显示a之值{ cout << "a:" << a << endl; }};class B: public A{protected:// 数据成员:int b; // 数据成员public:// 公有函数:B(int x, int y): A(x) , b(y){ } // 构造函数void Show() const // 显示相关信息{A::Show(); // 调用基类A的成员函数Show()cout << "b:" << b << endl; // 显示b之值}};int main(void) // 主函数main(void){B obj(5, 18); // 定义对象obj.Show(); // 显示相关信息system("PAUSE"); // 调用库函数system( ),输出系统提示信息return 0; // 返回值0, 返回操作系统}4.改正下面程序中的错误,使其能正常运行。
// 文件名: main.cpp //1 #include <iostream> // 预处理命令//2 using namespace std; // 使用标准命名空间std //3//4 // 基类Base //5 class Base //6 { //7 private: //8 // 数据成员: //9int m; // 数据成员//10//11 public: //12 // 公有函数: //13 Base(int a): m(a){ } // 构造函数//14Base(const Base ©) {m=copy.m } // 复制构造函数//15void Show() const // 显示m之值//16{ cout << "m:" << m << endl; } //17 }; //18//19 // 派生灰Derived //20 class Derived: private Base //21 { //22 protected: //23 // 数据成员: //24 int n; // 数据成员//25//26 public: //27 // 公有函数: //28 Derived(int a, int b): Base(a) ,n(b){ } // 构造函数//29void Show() const // 显示相关信息//30{ //31` Base::Show(); // 调用基类Base的成员函数Show() //32cout << "n:" << n << endl; // 显示n之值//33 } //34 }; //35//36 int main(void) // 主函数main(void)//37{ //38 Derived obj(10, 18); // 定义对象//39obj.Show(); // 显示相关信息//40//41 system("PAUSE"); // 调用库函数system( ),输出系统提示信息//42return 0; // 返回值0, 返回操作系统//43} //445.定义Person(人)类,由Person分别派生出Teacher(教师)类和Cadre(干部)类,再由Teacher(教师)类和Cadre(干部)类采用多重继承方式派生出新类TeacherCadre (教师兼干部)类,各类之间的继承关系如图1.1所示。
图2.1 各类之间的继承关系要求:(1)在Person类中包含的数据成员有姓名(name)、年龄(age)、性别(sex)。
在Teacher 类还包含数据成员职称(title),在Cadre类中还包含数据成员职务(post),在TeacherCadre类中还包含数据成员工资(wages)。
(2)在类体中定义成员函数。
(3)每个类都有构造函数与显示信息函数(Show)。
#include<iostream>using namespace std;class Person{private:char name[20];int age;char sex[20];public:Person(char *n,int a,char *s):age(a){strcpy(name,n);strcpy(sex,s);}void Show(){cout<<"name:"<<name<<"\n"<<"age:"<<age<<"\n"<<"sex:"<<sex<<endl;}};class Teacher:virtual public Person{private:char title[20];public:Teacher(char *n,int a,char *s,char *t):Person(n,a,s){strcpy(title,t);}void Show(){cout<<"title:"<<title<<endl;}};class Cadre:virtual public Person{private:char post[20];public:Cadre(char *n,int a,char *s,char *p):Person(n,a,s){strcpy(post,p);}void Show(){cout<<"post:"<<post<<endl;}};class TeacherCadre:public Teacher,public Cadre{private:double wages;public:TeacherCadre(char *n,int a,char *s,char *t,char *p,double w):Person(n,a,s),Teacher(n,a,s,t),Cadre(n,a,s,p),wages(w){}void Show(){Person::Show();Teacher::Show();Cadre::Show();cout<<"wages:"<<wages<<endl;}};void main(){TeacherCadre obj("李顺",40,"男","教授","教学",6000);obj.Show();}6.定义Staff(员工)类,由Staff分别派生出Saleman(销售员)类和Manager(经理)类,再由Saleman(销售员)类和Manager(经理)类采用多重继承方式派生出新类SaleManager(销售经理)类,各类之间的继承关系如图1.2所示。