c派生类与继承实验报告精修订

合集下载

继承的应用实验报告

一、实验目的1. 理解继承的概念和作用。

2. 掌握Java中继承的实现方法。

3. 学习如何利用继承提高代码复用性。

4. 通过实验加深对继承的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编译器：Eclipse IDE3. 编程语言：Java三、实验内容1. 创建一个基类：Animal，包含属性name和方法eat()。

2. 创建两个派生类：Dog和Cat，分别继承自Animal类，并添加各自特有的属性和方法。

3. 创建一个主类：TestInheritance，在主函数中创建Animal、Dog和Cat的对象，并调用它们的方法。

四、实验步骤1. 创建基类Animal：```javapublic class Animal {private String name;public Animal(String name) { = name;}public void eat() {System.out.println(name + " is eating."); }}```2. 创建派生类Dog：```javapublic class Dog extends Animal {private String breed;public Dog(String name, String breed) {super(name);this.breed = breed;}public void bark() {System.out.println(name + " is barking."); }}```3. 创建派生类Cat：```javapublic class Cat extends Animal {private String color;public Cat(String name, String color) {super(name);this.color = color;}public void meow() {System.out.println(name + " is meowing."); }}```4. 创建主类TestInheritance：```javapublic class TestInheritance {public static void main(String[] args) {Animal animal = new Animal("Animal");Dog dog = new Dog("Buddy", "Labrador");Cat cat = new Cat("Kitty", "Black");animal.eat();dog.eat();dog.bark();cat.eat();cat.meow();}}```五、实验结果与分析1. 运行主类TestInheritance，观察控制台输出：```Animal is eating.Buddy is eating.Buddy is barking.Kitty is eating.Kitty is meowing.```2. 分析结果：（1）Animal类作为基类，包含一个私有属性name和一个方法eat()。

面向对象程序设计(C++)实验报告

面向对象程序设计（C++）实验报告姓名：刘九州学院：数学与计算机学院班级：10级计算机大类三班学号：100511314实验5 单继承一、实验目的1．掌握派生的类别与方式；2．了解派生类中如何使用基类的成员、基类成员在派生类中的访问控制；3. 掌握继承中构造函数和析构函数的调用过程。

二、实验内容及步骤1.给出一个Document类，从Document派生出Book类，增加PageCount变量。

在主函数中进行测试，创建Book类对象并进行初始化，输出书名和页数。

2.设计一个单基继承的类层次程序，利用Person类派生出Student类，增加属性xh（学号），Person类中至少有姓名、年龄等数据成员，成员函数中构造函数对其初始化，析构函数释放相应存储单元，输出函数输出其数据成员的值，其它成员函数根据需要添加，在主函数中进行测试。

3.设计一个人员类person和一个日期类date，由人员类派生出学生类student和教师类professor，学生类和教师类的数据成员birthday为日期类。

在主函数中进行测试。

三、实验源程序和运行结果实验（一）源程序：#include<iostream>#include<string>using namespace std;class Document{public:Document(){};~Document();Document(char*name);char *Name;void PrintNameOf();};Document::Document(char*name){Name=new char[strlen(name+1)];strcpy(Name,name);}Document::~Document(){delete []Name;}void Document::PrintNameOf(){cout<<Name<<endl;}class Book:public Document{public:int PageCount;Book(char *a,int b):Document(a){PageCount=b;}};void main(){char BookName[20];int n;cout<<"请输入书名："<<endl;cin>>BookName;cout<<"请输入书的页数："<<endl;cin>>n;Book b(BookName,n);cout<<"书名为："<<<<endl;cout<<"页数为："<<b.PageCount<<endl;}运行结果：实验（二）源程序：#include<iostream>#include<string>using namespace std;class person{public:person(){name="张三";age=0;}person(string c,int a){name=c;age=a;}~person(){}void setname(string c){name=c;}string getname(){return name;}void setage(int a){age=a;}int getage(){return age;}private:string name;int age;};class student:public person{public:student(){xh=0;}student(int d){xh=d;}student(string c,int a,int d):person(c,a){xh=d;}~student(){}void setxh(int d){xh=d;}int getxh(){return xh;}private:int xh;};void main(){string c;cout<<"请输入学生的姓名：\n";cin>>c;cout<<"请输入学生的年龄：\n";int a;cin>>a;cout<<"请输入学生的学号：\n";int d;cin>>d;student n(c,a,d);cout<<"请输入学生的姓名为："<<n.getname()<<endl;cout<<"请输入学生的年龄为："<<n.getage()<<endl;cout<<"请输入学生的学号为："<<n.getxh()<<endl; }运行结果：实验（三）源程序：#include<iostream>using namespace std;class person{public:person(){name="张三";age=0;}person(string c,int a){name=c;age=a;}~person(){}void setname(string c){name=c;}string getname(){return name;}void setage(int a){age=a;}int getage(){return age;}private:string name;int age;};class date{public:date(){year=2011;month=12;day=17;}~date(){}date(int y,int m,int d){year=y;month=m;day=d;}int getyear(){return year;}int getmonth(){return month;}int getday(){return day;}private:int year;int month;int day;};class student:public person{public:student(){// birthday.date();}student(int y,int m,int d):birthday(y,m,d){}~student(){}void getbirthday(){cout<<"学生的生日为：\n";cout<<birthday.getyear()<<"年"<<birthday.getmonth()<<"月"<<birthday.getday()<<"日"<<endl;}private:date birthday;};class teacher:public person{public:teacher(){// birthday.date();}teacher(int y,int m,int d):birthday(y,m,d){//birthday.date(y,m,d);}~teacher(){}void getbirthday(){cout<<"老师的生日为：\n";cout<<birthday.getyear()<<"年"<<birthday.getmonth()<<"月"<<birthday.getday()<<"日"<<endl;}private:date birthday;};void main(){cout<<"请输入学生的生日："<<endl;int y,m,d;cin>>y>>m>>d;student s(y,m,d);cout<<"请输入老师的生日："<<endl;cin>>y>>m>>d;teacher t(y,m,d);s.getbirthday();t.getbirthday();}运行结果：实验6 多继承一、实验目的1．掌握多基继承的使用，访问方法；2．理解类层次中访问规则；3．掌握虚基类的定义及使用。

实验四：派生类和继承(一)

福建农林大学实验报告实验4 派生类和继承（一）一、实验目的和要求（1）掌握派生类的声明与定义方法，进一步理解类的继承的概念，能够定义和使用类的继承关系。

（2）熟悉公有派生和私有派生的访问特性。

二、实验内容和原理1、(1)定义一个基类Animal，该类具有私有整型成员变量age,weight，构造派生类Dog公有继承Animal。

Dog类新增私有成员变量color，新增成员函数SetAge（int n）中直接给age赋值，新增成员函数SetWeight（int m）中直接给weight赋值，查看编译结果，并分析结果。

(2)将类Anima l中的age和weight为公有成员，重做第一步，并分析结果。

(3)将类Animal中的age和weight 为保护成员，重做第一步，并分析结果。

（4）将派生类Dog的继承方式改为私有继承方式和保护继承方式重做以上各小题，并分析结果。

2、程序分析题（写出程序的输出结果，并分析结果）。

三、实验环境1. 硬件：PC机；2. 软件：Windows操作系统、Visual C++ 6.0四、算法描述及实验步骤1、（1）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<"Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";cin>>y;cout<<endl;cout<<"The dog's age is "<<a.SetAge(x)<<endl;cout<<"The dog's age weight is"<<a.SetWeight(y)<<endl; return 0;}（2）：#include <iostream.h>class animal{public:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";return 0;}（3）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";cin>>y;cout<<endl;cout<<" The dog's age is "<<a.SetAge(x)<<endl;cout<<" The dog's age weight is "<<a.SetWeight(y)<<endl; return 0;}（4）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";return 0;}（5）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";cin>>y;cout<<endl;cout<<" T The dog's age is "<<a.SetAge(x)<<endl;cout<<" The dog's age weight is "<<a.SetWeight(y)<<endl; return 0;}（6）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";return 0;}（7）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";cin>>y;cout<<endl;cout<<" The dog's age is "<<a.SetAge(x)<<endl;cout<<" The dog's age weight is "<<a.SetWeight(y)<<endl; return 0;}（8）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";return 0;}（9）：#include <iostream.h>class animal{private:int age,weight;};class dog:public animal{private:char color[10];public:int SetAge(int n){age=n;return n;}int SetWeight (int m){weight=m;return m; }};int main(){ int x,y;dog a;cout<<" Please input dog's age ：";cin>>x;cout<<endl;cout<<" Please input dog's weight：";cin>>y;cout<<endl;cout<<" The dog's age is "<<a.SetAge(x)<<endl;cout<<" The dog's age weight is "<<a.SetWeight(y)<<endl; return 0;}2#include<iostream.h>class A{public: A(int i,int j){a=i;b=j;}void move(int x,int y){a+=x;b+=y;}void display(){cout<<"("<<a<<","<<b<<")"<<endl;} private:int a,b;};class B:public A{public: B(int i,int j,int k,int l):A(i,j),x(k),y(l){}void display(){cout<<x<<","<<y<<endl;}void fun1(){move(13,15);}void fun2(){A::display();}void fun3(){display();}private:int x,y;int main(){A aa(2,4);aa.display();B bb(5,6,7,8);bb.fun1();bb.fun2();bb.fun3();bb.A::display();bb.B::display();return 0;}五、调试过程1、调试程序，截图如下：原因分析：在public继承中void display 中的display打错成diaplay。

类的继承与多态性实验报告

类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性，现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。

多态的基础是继承（包括了接口的实现）和方法的覆盖。

什么是多态多态对应的英文单词是polymorphism，百度翻译给出的翻译是：n.多型现象，多态性; 多机组合形式;按字面意思就是多种状态、形态、姿态等等，潜台词就是某个东西具有多种状态、形态、姿态等等。

那是什么东西呢？在面向对象的编程语言里面（当然就包括Java了）就是某个方法或函数。

那方法的多种状态、形态、姿态有是个什么意思呢？这其实是指同一个方法具有多个方法体，就是方法的实现。

而方法的相同与否是由方法签名决定的。

所以，多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。

状态、形态、姿态指的就是行为特征。

多态在Java中的技术基础然而，在Java中，同一个类里面是不可能存在两个签名相同而实现不同的方法的，否则的话会导致无法判断该执行哪个方法，因此在编译时就会报错。

所以，肯定是在两个类中才有可能存在两个签名相同而实现不同的方法，一个实现在这个类，另一个实现在另一个类。

而如果这两个类毫无瓜葛，那么肯定就与多态的本质（同一个类的同一个方法却具有不同的行为特征）自相矛盾了。

所以，这两个类肯定是有某种联系的。

我们再想想，什么概念是能够让两个不同的类却又能称为同一个类的？答案就是类的继承/扩展，就是现实中的“某东西是某类东西”的概念，就是“具体和抽象”的思想。

比如，男人是人，女人也是人，男人类和女人类就借助于人类建立了某种联系，而人类具有的某个行为在男人类和女人类中是有着不同体现的，比如人类的吃饭这个行为，男人类的体现是狼吞虎咽，女人类的体现是细嚼慢咽。

例子不是很恰当，但意思就是这么个意思。

所以说，Java里面多态的技术基础就是方法的覆盖，当然，在Java中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。

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

《C++面向对象程序设计》实验内容实验1 C++程序设计初步1.实验目的（1）了解在C++编译系统（Visual C++6.0）上如何编辑、编译、连接和运行一个C++程序。

（2）通过运行简单的C++程序, 初步了解C++源程序的结构和特点。

（3）掌握简单C++程序的编写和调试方法。

（4）掌握重载函数的定义方法。

（5）能正确使用引用型变量。

2.实验内容和步骤（1）在Visual C++环境下编译和运行C++程序①先进入Visual C++6.0环境。

②在自己指定的子目录中建立一个名为test.cpp的新文件。

③从键盘输入以下程序int main(){int a,b;c=a+b;cout>> “a+b=”>>a+b;}选择Build→Compile test.cpp命令, 对此源程序进行编译。

观察和分析编译信息。

⑤根据编译信息指出的错误, 修改程序。

再进行编译, 如果还有错, 再重复此过程, 直到编译不出错为止。

⑥选择Build→Build test.exe命令, 对程序进行连接, 如果不出错, 就会生成可执行程序test.exe。

⑦选择Build→Execute test.exe命令, 执行可执行程序test.exe。

观察屏幕的变化。

在输出窗口应显示程序运行结果。

⑧分析结果是否正确, 如果不正确或认为输出格式不理想, 可以修改程序, 然后重新执行以上④和⑧步骤。

改过后的程序:#include<iostream>using namespace std;int add(int x,int y){int z;z=x+y;return(z);}int main(){int a,b,c;cin>>a>>b;c=add(a,b);cout<<"a+b="<<c<<endl;return 0;}实验2 C++对C的扩充（2）编一个程序, 用来求2个或3个正整数中的最大数。

C++上机实验报告实验五

｛
ａge=n;
}
／／数据输出函数
ｖoｉdDog::showNumber（)
{
cout＜<"Nｕmbｅｒ:"<<numbｅｒ<<eｎｄl;
}
ｖｏｉd Doｇ::shｏwＡgｅ()
｛
ｃouｔ＜＜"Age:"＜＜age<<endl;
}
ｉntｍaｉn()
{
Dｏgdog1（１２,０);
ﻩdｏｇ1.setAge（7);
ﻩvｏid sｈowNuｍber（);
ﻩvｏｉd shoｗＡｇe(）;
｝；
Ａnimal::Ａｎimａｌ(int a)//Ａnimal构造函数
{
age=ａ;
｝
Dog:：Dog(ｉｎtn，iｎｔa）//Ｄog构造函数
{
numbｅｒ=ｎ;
ﻩａｇe=a;
}
ｖoｉdＤｏｇ:：sｅtAge(ｉｎt n)／／Doｇ成员函数，ｓｅｔAｇｅ
ｅrror C2２４８：‘ａge’ :ｃａnnot access prｉｖａtｅmember deｃｌarｅdｉn class ‘Aniｍaｌ’
把ａgｅ改为公有成员变量后重新编译就可以了。程序名：lab7_1.cpｐ。
２．编写程序定义一个基类BaseClass,构造其派生类DｅriｖeｄＣlass，在构造函数和析构函数中用ｃout输出提示信息,观察构造函数和析构函数的执行情况。程序名:lａb7＿2．cpp。
3.用debug功能跟踪程序ｌａb7_2的执行过程,观察基类和派生类的构造函数和析构函数的执行情况。
４.编写程序定义一个车（ｖehicle）基类,由此派生出自行车(ｂicyclｅ）类、汽车(motorｃａr)类,注意把vehicle派生为虚基类。再从ｂicycｌe和ｍotorｃar派生出摩托车(motorcycｌｅ)类,在mａin()函数中测试这个类。程序名：lab7_3.cpp。

C++实验三继承和派生类(附答案)

实验三继承和派生类实验目的和要求1．理解类的继承的概念，能够定义和使用类的继承关系。

2．掌握派生类的声明与定义方法。

3．熟悉公有派生和私有派生的访问特性。

4．学习虚基类在解决二义性问题中的作用。

实验内容1.先阅读下面的程序，分析程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

（1）#include<iostream.h>class A{public:A(){cout<<"A::A() called.\n";}~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){cout<<"B::B() called.\n";buf=new char[i];}~B(){delete []buf;cout<<"B:~B() called.\n";}private:char *buf;};void main(){B b(10);}（2）#include<iostream.h>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<<")"<<endl;}~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;}};void main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();}（3）#include<iostream.h>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,virtual public A{public:D(int a,int b,int c):C(a,b,c),A(c){cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};void main(){D d(7,8,9);d.f();d.display();}#include<iostream.h>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;}};void main(){TopLevel obj;}2.调试下列程序，并对程序进行修改后再调试，指出调试中的出错原因。

继承与派生实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验五 C#类的设计和实现,(2)

实验四类的设计和实现（2）实验学时：2学时实验类型：验证实验要求：必做一、实验目的1.掌握类的继承的实现；2.掌握派生类、抽象类、抽象方法的使用；3.了解接口的实现；4.了解事件的实现二、实验内容实验1类的继承的实现实验要求：参照课本例8.3，创建基类Person和派生类Teacher。

基类Person包含实例字段name和age；虚函数GetInfo（）显示个人信息。

派生类Teacher除了包含基类的name和age字段，还包含自己的TeacherID字段，并使用关键字override来重写方法GetInfo （）。

源程序：using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication12{public class Person{public string name;public uint age;public Person(string name, uint age){ = name;this.age = age;}public virtual void GetInfo(){Console.WriteLine("Name:{0}", name);Console.WriteLine("Age:{0}", age);1}}public class Teacher : Person{public string TeacherID;public Teacher(string name, uint age, string id): base(name, age){this.TeacherID = id;}public override void GetInfo(){base.GetInfo();Console.WriteLine("TeacherID:{0}", TeacherID);}}class Program{static void Main(string[] args){Teacher objteacher = new Teacher("Zhangying", 20, "1245713131");objteacher.GetInfo();Console.ReadKey();}}}运行结果：实验2 抽象类、抽象方法、多态性的实现实验要求：创建抽象基类Shape和派生类Rectangle、Circle。

实验报告模版

实验4 派生类的实现姓名张识翼班级电信3班学号14132201576一、实验目的通过vc开发环境下派生类和对象的设计与实现，了解单继承和多继承的基本方法，掌握派生类的基本设计和编程方法。

二、实验主要内容1、采用单一继承实现学生和毕业生两个类，设计相关的数据成员和函数，编程测试继承情况。

2、单位员工类（时薪工、计件工、经理、佣金工）设计，其中时薪工每周超过50小时后算加班，加班薪水为原薪水的200%；佣金工每周得到保底薪水，再此基础上按比例从该周内销售额中提成；经理则拿固定的周薪。

3、设计研究生类，该类派生自学生类和教师类。

三、实验程序#include<iostream.h>#include<string.h>class Student // 定义基类vehicle{public: // 公有函数成员Student(int n,char *na,int g):number(n),grade(g){strcpy(name,na);}int getNumber(){return number;}char * getName(){return name;}int getGrade(){return grade;}void display(){cout<<"学号："<<number<<endl<<"姓名："<<name<<endl<<"年级："<<grade<<endl;}private: // 私有数据成员int number; // 学号char name[20]; // 姓名int grade; // 年级};class Graduate:public Student //定义毕业生类{char designSubject[20];public:Graduate(int n,char *na,char * deSub,int g=4):Student(n,na,g){strcpy(designSubject,deSub);}void display(){Student::display();cout<<"设计题目："<<designSubject<<endl;}};void main() //创建对象{Student li(2,"Li Ming",3);Graduate zhang(3,"Zhang Gang","学生成绩管理系统"); // 显示对象的相关信息li.display(); cout << endl<<"-----------------------------------" <<endl;zhang.display();}#include <iostream.h>#include <string.h>class Person{protected:char m_strName[10];int m_nSex;int m_nAge;public:Person(char *name,int age,char sex){strcpy(m_strName, name);m_nSex= (sex=='m'?0:1 );m_nAge = age;}void setName(char *name){strcpy(m_strName, name);}void setSex(int sex){m_nSex= (sex=='m'?0:1 );}void setAge(int age){m_nAge = age;}char * getName(){return m_strName;}int getAge(){return m_nAge;}int getSex(){return m_nSex;}void ShowMe(){cout<<" 姓名："<<m_strName<<endl;cout<<" 性别："<<(m_nSex==0?"男":"女")<<endl;cout<<" 年龄："<<m_nAge<<endl;}};class Teacher : public Person{char m_strDept[20];int m_fSalary;public:Teacher(char *name,int age,char sex,char *dept,int salary):Person(name,age,sex){strcpy(m_strDept, dept);m_fSalary = salary;}void ShowMe(){Person::ShowMe();cout<<" 工作单位："<<m_strDept<<endl;cout<<" 月薪："<<m_fSalary<<endl;}void setSalary(int salary){m_fSalary = salary;}char * getDept(){return m_strDept;}int getSalary(){return m_fSalary;}};class Student : public Person{char m_strID[12];char m_strClass[12];public:Student(char *name,int age,char sex,char *ID,char *Class) :Person(name,age,sex){strcpy(m_strID, ID);strcpy(m_strClass, Class);}void ShowMe(){ cout<<" 学号："<<m_strID<<endl;Person::ShowMe();cout<<" 班级："<<m_strClass<<"\n";}void setID(char * ID){strcpy(m_strID, ID);}void setClass(char *Class){strcpy(m_strClass, Class);}char* getID(){return m_strID;}char* getClass(){return m_strClass;}};class Master:public Student, public Teacher{public:Master(char *name,int age,char sex,char *ID,char *Class,char *dept,int salary) :Student(name,age,sex,ID,Class),Teacher(name, age, sex, dept, salary){}void ShowMe(){Student::ShowMe();cout<<" 工作单位："<<getDept()<<endl;cout<<" 月薪："<<getSalary()<<endl;}};void main(){ // 定义三个不同类的对象Teacher teacher1("刘馨",38,'m',"计算机系",3800);Student std1("刘丽",20,'f',"03016003","计算机03");Master master("张鑫",25,'f',"003","机械052","机械系",1000);//显示各类人员的属性teacher1.ShowMe();cout<<"--------------------"<<endl;std1.ShowMe();cout<<"--------------------"<<endl; master.ShowMe();}#include<iostream>#include<string.h>using namespace std;class employee //员工类{protected:char name[20]; //员工名字char id[20]; //员工号double salary; //员工薪水public:employee(){};employee(char* emp_name,char* emp_id) //建立员工基本信息{strcpy(name,emp_name);strcpy(id,emp_id);}char* get_name() //获取名字{return name;}char* get_id() //获取职工号{return id;}double get_salary() //应得薪水{return salary;}};class hourlyworker:public employee //时薪工类{protected:int hours;double hourpay;public:hourlyworker(){};hourlyworker(char* hour_name,char* hour_id,int hour,double pay):employee(hour_name,hour_id){hours=hour; hourpay=pay;}char *get_name(){return employee::get_name ();}char *id(){return employee::get_id ();}int get_hours() //获取工作时间{return hours;}double get_hourpay() //获取小时工资{return hourpay;}double get_salary() //时薪工工资计算{if(hours<=50)salary=hourpay*hours;elsesalary=hourpay*50+2*hourpay*(hours-50);return salary;}};class pieceworker:public employee //计件工类{protected:int pieces; //工件数double piecepay; //每个工件赢得的工资public:pieceworker(){};pieceworker(char* piece_name,char* piece_id,int piece,double piece_pay): employee(piece_name,piece_id){pieces=piece; piecepay=piece_pay;}char *get_name(){return employee::get_name ();}char *id(){return employee::get_id ();}int get_pieces() //获取工件数{return pieces;}double get_pay() //每件的工资{return piecepay;double piece_salary() //计件工工资{salary=pieces*piecepay;return salary;}};class manager:public employee{public:manager(char* man_name,char* man_id):employee(man_name,man_id){}char *get_name(){return employee::get_name ();}char *id(){return employee::get_id ();}double manager_salary() //经理工资{return salary=3000;}};class commissionworker:public employee //佣金工类{protected:double basesalary; //保底新书double total; //一周内的销售总额double percent; //提成的额度public:commissionworker(){};commissionworker(char* com_name,char* com_id,double com_basesalary,double com_total,double com_percent): employee(com_name,com_id){basesalary=com_basesalary;total=com_total;percent=com_percent;}char *get_name(){return employee::get_name ();char *id(){return employee::get_id ();}double get_base_pay() //保底薪水{return basesalary;}double get_com_total() //销售总额{return total;}double get_com_percent() //销售额中提成{return percent;}double com_salary() //佣金工的工资{salary=basesalary+total*percent;return salary;}};void main(){cout<<"输出“时薪工”的相关信息："<<"\n";hourlyworker hworker("John","000001",65,20.5);cout<<" hourlyworker'名字: "<<hworker.get_name ()<<"\n";cout<<" hourlyworker'职工号: "<<hworker.get_id ()<<"\n";cout<<" hourlyworker'工作小时数:"<<hworker.get_hours ()<<"\n";cout<<" hourlyworker'每小时金额:"<<hworker.get_hourpay ()<<"\n";cout<<" hourlyworker'总工资: "<<hworker.get_salary ()<<"\n";cout<<"**********************************************"<<"\n";cout<<"输出“计件工”的相关信息："<<"\n";pieceworker pworker("Tom","000002",100,25.5);cout<<" pieceworker'名字: "<<pworker.get_name ()<<"\n";cout<<" pieceworker'职工号: "<<pworker.get_id ()<<"\n";cout<<" pieceworker'工件数: "<<pworker.get_pieces ()<<"\n";cout<<" pieceworker'每件的金额:"<<pworker.get_pay ()<<"\n";cout<<" pieceworker'总工资: "<<pworker.piece_salary ()<<"\n";cout<<"**********************************************"<<"\n";cout<<"输出“经理”的相关信息："<<"\n"; manager manag("Jack","000003");cout<<" manager'名字: "<<manag.get_name ()<<"\n";cout<<" manager'职工号:"<<manag.get_id ()<<"\n";cout<<" manager'总工资:"<<manag.manager_salary ()<<"\n";cout<<"**********************************************"<<"\n";cout<<"输出“佣金工”的相关信息："<<"\n";commissionworker cworker("Jim","000004",500,234.6,0.01);cout<<" commissionworker'名字: "<<cworker.get_name ()<<"\n";cout<<" commissionworker'职工号: "<<cworker.get_id ()<<"\n";cout<<" commissionworker'保底工资:"<<cworker.get_base_pay ()<<"\n";cout<<" commissionworker'销售额: "<<cworker.get_com_total ()<<"\n";cout<<" commissionworker'提成额度:"<<cworker.get_com_percent ()<<"\n";cout<<" commissionworker'总工资: "<<_salary ()<<"\n";cout<<"**********************************************"<<"\n";}四、实验结果五、实验总结实验四比较贴近生活的实际问题，在我写这些程序时候参考了书上的例子。

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

面向对象程序设计实验报告实验报告（1）2015.6【实验作者】学号：姓名：班级：教学站：【实验名称】实验一：熟悉C++程序的风格和C++程序的上机全过程【实验目的】1．熟悉C++程序的风格，熟悉实验环境。

2．练习C++程序的输入、修改、编译、连接与运行的全过程。

3．本实验有4个程序【实验内容】1. 习题2.2下面是一个C程序，改写它，使它采用C++风格的I/O语句。

（1）该程序做什么工作？输入两个整数，求两个整数的大于1 的最小公约数[（另外请教下毛老师：如果最小公约数与最小数相等时，我觉得也有可能这个数是两个数的大于1 的最小公约数）即7与14的公约数为1，7按题意的话，要大于1，那么7也是这两个数的最小公约数，但程序不认为它们具有公约数]。

（2）该程序中那几个数是由键盘输入的？那几个数是输出的？那几个数是临时变量？a与b 由键盘输入；d 是输出的；a，b，d，min 都是临时变量。

（3）用C++风格的I/O语句是什么？#include <iostream.h> cout<<与cin>>（4）写出该程序的算法（用流程图表示）框图1：（5）该程序你有否上机编译、连接、运行通过。

有上机编译连接并运行通过，但有些疑问！2. 习题 2.20分析下面程序的输出结果：（1）该程序做什么工作？利用引用函数改变一个变量的值。

（2）该程序有几个函数？其中f函数是什么函数？其功能是什么？一个函数，F函数是一个引用返回值的函数，并且该函数参数也为一个引用，函数功能是送入一个对变量引用，将变量+10后送回。

成为对返回值的引用。

（3）写出该程序的算法（用流程图表示）框图2：（4）该程序你有否上机编译、连接、运行通过。

该程序有上机编译并连接运行通过。

3. 习题2.23 建立一个被称为sroot( )的函数，返回其参数的二次根。

重载sroot( )三次，让它分别返回整数、长整数与双精度数的二次根（为了实际计算二次根，可以使用标准库函数sqrt( )）。

实验19+类的继承

实验19 类的继承一、实验目的和要求1．学习使用继承方式派生新类的方法。

2．进一步加深对访问权限的理解。

3．掌握继承中二义性问题的解决办法。

4．进一步锻炼针对类的编程能力。

二、实验准备知识点1．继承权限（1）继承权限有三种：公有派生、私有派生、保护派生。

（2）公有派生中，基类中的public成员在派生类中是public成员，protected成员在派生类中是protected成员。

（3）私有派生中，基类中的public成员在派生类中是private成员，protected成员在派生类中是private成员。

（4）保护派生中，基类中的public成员在派生类中是protected成员，protected成员在派生类中是protected成员。

（5）class定义的默认继承权限为private，struct定义的默认继承权限为public。

（6）无论哪一种继承权限，其基类的private成员均不能为派生类所继承。

2．继承种类有两种继承：单一继承（一个基类）和多重继承（多个基类）。

3．初始化基类成员的方法（1）使用派生类前需要先对基类初始化，初始化基类成员通常通过派生类的构造函数实现。

（2）如果初始化列表中没有调用基类构造函数的初始化项，则自动调用基类的无参构造函数进行初始化。

（3）多重继承中基类构造函数的调用顺序只与派生类继承基类的顺序有关。

（4）一个类的构造函数只能对它的直接基类的构造函数传递实参。

4．冲突的解决办法在多重继承中，如果不同的基类具有名字相同的公有成员或保护成员，此时若在派生类对象的成员名前加上基类名，通过作用域运算符”::”连接，即可解决冲突。

5．支配规则（就近原则）如果派生类的新增成员和继承成员同名，则通过派生类对象访问该同名成员时，所访问的是新增成员，而不是继承成员。

6．赋值兼容性规则（1）公有派生类对象可以赋值给基类对象。

（2）基类对象不可以赋值给派生类对象。

（可以/不可以）（3）公有派生类对象的地址可以赋值给基类的指针变量。

新标准C++程序设计5. 继承和派生

所有的学生都有的共同方法（成员函数）：是否该留级是否该奖励
5
需要继承机制的例子
而不同的学生，又有各自不同的属性和方法研究生导师系大学生系中学生竞赛特长加分
6
需要继承机制的例子
➢如果为每类学生都从头编写一个类，显然会有不少重复的代码，浪费。
7
需要继承机制的例子
➢如果为每类学生都从头编写一个类，显然会有不少重复的代码，浪费。
class CPoint {
double x,y; };
class CCircle:public CPoint {
double r; };
31
复合关系的使用
几何形体程序中，需要写“点”类，也需要写“圆”类
class CPoint {
double x,y; };
class CCircle:public CPoint {
class CStudent { private: string name; string id; //学号 char gender; //性别,'F'代表女，'M'代表男 int age; public: void PrintInfo(); void SetInfo( const string & name_,const string & id_, int age_, char gender_ ); string GetName() { return name; }
int v3; };
13
派生类对象的内存空间
派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前。

继承与多态实验报告

继承与多态实验报告继承与多态实验报告在面向对象编程中，继承和多态是两个重要的概念。

通过继承，我们可以创建新的类，并从现有的类中继承属性和方法。

而多态则允许我们使用父类的引用来指向子类的对象，实现同一操作具有不同的行为。

本实验旨在通过实际的编程实践，加深对继承和多态的理解。

实验一：继承在这个实验中，我们创建了一个动物类（Animal），并从它派生出了两个子类：狗类（Dog）和猫类（Cat）。

动物类具有一些共同的属性和方法，如名字（name）和发出声音（makeSound）。

子类继承了父类的属性和方法，并可以添加自己的特定属性和方法。

在编写代码时，我们首先定义了动物类，并在其中实现了共同的属性和方法。

然后，我们创建了狗类和猫类，并分别在这两个类中添加了自己的特定属性和方法。

通过继承，我们可以在子类中直接使用父类的方法，并且可以根据需要进行重写。

实验二：多态在这个实验中，我们使用多态的概念来实现一个动物园的场景。

我们定义了一个动物园类（Zoo），并在其中创建了一个动物数组。

这个数组可以存储不同类型的动物对象，包括狗、猫等。

通过多态，我们可以使用动物类的引用来指向不同类型的动物对象。

例如，我们可以使用动物类的引用来指向狗对象，并调用狗类特有的方法。

这样，我们可以统一处理不同类型的动物对象，而不需要为每种类型编写特定的处理代码。

实验三：继承与多态的结合应用在这个实验中，我们进一步探索了继承和多态的结合应用。

我们定义了一个图形类（Shape），并从它派生出了三个子类：圆形类（Circle）、矩形类（Rectangle）和三角形类（Triangle）。

每个子类都实现了自己的特定属性和方法。

通过继承和多态，我们可以在图形类中定义一些通用的方法，如计算面积和周长。

然后，我们可以使用图形类的引用来指向不同类型的图形对象，并调用相应的方法。

这样，我们可以轻松地对不同类型的图形进行统一的处理。

结论：通过本次实验，我们进一步理解了继承和多态的概念，并学会了如何在编程中应用它们。

c++派生类与继承实验报告

~Myarray(){};
void input()
{
int i;
for(i=0;i<length;i++)
{
cout<<"输入数组的第"<<i+1<<"个元素："<<'\n';
cin>>alist[i];
}
}
int getlen(){return length;}
void display()
{
for(int i=0;i<length;i++)
（2）声明一个类ReArray继承类MyArray,在该类中定义一个函数，具有将输入的整数进行倒置的功能。
（3）声明一个类AverArray继承类MyArray,在该类中定义一个函数，具有求输入的整数平均值的功能。
（4）声明一个NewArray类，同时继承了类SortArray,ReArray和AverArray,使得类NewArray的对象同时具有排序、倒置和求平均值的功能。在继承的过程中声明MyArray为虚基类，体会虚基类在解决二义性问题中的作用。
（2）设计三个类的相应的构造函数、复制构造函数，完成初始化和对象复制
（3）设计Triangle类的成员函数完成三条边是否能构成三角形的检验和三角形面积计算，面积显示。
实验代码：#include<iostream>
#include<>
using namespace std;
class Point //定义一个点的类，坐标为（x,y）
();
();
return 0;
}

《C++程序设计》电子教案第5章继承和派生

// 使用基类成员i，j
// 使用基类成员i，j
4．私有继承和保护继承

私有继承：派生类对基类的私有继承使用关键字private描述（可缺省），基类的所有公有段和保护段成员都成为派生类的私有成员。保护继承：派生类对基类的保护继承使用关键字protected描述，基类的所有公有段和保护段成员都成为派生类的保护成员，保护继承在程序中很少应用。
常用的三种继承方式：
1．公有继承（public）公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的。 2．私有继承（private）私有继承的特点是基类的公有成员和保护成员作为派生类的私有成员，并且不能被这个派生类的子类访问。 3．保护继承（protected）保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。
第5章继承和派生

5.1 5.2 5.3 5.4
基类和派生类单继承多继承虚基类
5.1 基类和派生类

5.1.1 5.1.2 5.1.3 5.1.4
派生类的定义格式派生类的三种继承方式访问控制基类和派生类的关系
返回首页

称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。派生类可以具有基类的特性，共享基类的成员函数，使用基类的数据成员，还可以定义自己的新特性，定义自己的数据成员和成员函数。

public: void initr(float x,float y,float w,float h) { initp(x,y); //调用基类的公有成员 W=w;H=h; } float getH(){return H;} float getW(){return W;} private: float W,H; }; void main() { rectangle rect; rect.initr(2,3,20,10); rect.move(3,2); cout<<"the data of rect(x,y,w,h):"<<endl; cout<<rect.getx()<<","<<rect.gety()<<","<<rect.getW()<<"," << rect.getH()<<endl; }

继承实验报告实验总结

一、实验目的本次实验旨在通过C++语言对类的继承机制进行深入学习和实践，了解不同继承方式下基类成员在派生类中的访问权限，掌握构造函数与析构函数的调用时机与顺序，以及虚基类在多继承中的特殊作用。

二、实验内容1. 类的继承方式（1）公有继承在公有继承中，基类的公有成员和保护成员在派生类中分别作为公有成员和保护成员，派生类的成员函数可以直接访问它们，而无法直接访问基类的私有成员。

在类的外部，派生类的对象可以访问继承下来的基类公有成员。

（2）私有继承在私有继承中，基类的公有成员和保护成员作为派生类的私有成员，派生类的成员函数可以直接访问它们，但无法直接访问基类的私有成员。

在类外部，派生类的对象无法访问基类的所有成员。

（3）保护继承在保护继承中，基类的公有成员和保护成员作为派生类的保护成员，派生类的成员函数可以直接访问它们，但无法直接访问基类的私有成员。

在类外部，派生类的对象无法访问基类的所有成员。

2. 构造函数与析构函数的调用时机与顺序在多继承中，构造函数的调用顺序如下：（1）先调用所有基类的构造函数；（2）再调用派生类中子对象类的构造函数（如果派生类中没有子对象），最后调用派生类的构造函数；（3）析构函数的调用顺序与构造函数相反，先调用派生类的析构函数，再调用子对象类的析构函数，最后调用基类的析构函数。

3. 虚基类的构造函数与普通基类的构造函数在调用时的不同在多继承中，若存在虚基类，则其构造函数只会被调用一次，即使它在多个派生类中被继承。

这是因为虚基类在第一次继承时就已经初始化，后续的继承将直接使用已初始化的虚基类实例。

三、实验结果与分析1. 通过实验，我们验证了不同继承方式下基类成员在派生类中的访问权限，明确了公有继承、私有继承和保护继承的区别。

2. 实验结果显示，在多继承中，构造函数和析构函数的调用顺序符合预期，派生类可以正确地调用基类和子对象类的构造函数和析构函数。

3. 通过实验，我们了解了虚基类在多继承中的作用，避免了重复初始化同一基类的问题。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

c派生类与继承实验报
告
SANY标准化小组 #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN#
实验2 派生类与继承
实验课程名：面向对象程序设计（C++）
专业班级：学号：姓名：
实验时间：实验地点：指导教师：
二、实验内容
一、构造一个类Geometry 及其派生类，该类主要实现关于几何图形的基本操作。

对于基类“几何图形”，有求面积、求体积的函数（纯虚函数），其派生类圆和矩形主要有初始化（构造函数），求面积，求周长操作，类圆的派生类圆球和圆柱有求表面积、体积操作。

试在主函数中分别定义圆、圆球、圆柱以及矩形的对象，并调用其成员函数实现其相应操作。

实验代码如下：
#include<iostream>
using namespace std;
class Geometry
{
public:
Geometry(){}
~Geometry(){}
double GetArea(){}//求面积函数
double GetPerimeter(){}//求体积函数
double Getcolume(){}//求周长函数
Circle
radiums
Circle()
~Circle() Ball
Ball()
~Ball() Geometry
Geometry()
~Geometry()
GetArea()
GetPerimeter()
Getcolume()
show()
Column Column()
~Column()
Rectangl Rectangle() ~Rectangle()
};
double Column::GetArea()
{
return(2**R()*R()+2**R()*L());
}
double Column::GetPerimeter()
{
return*R()*R()*L());
}
Column::show()
{
cout<<"圆柱的体积为："<<GetPerimeter()<<' '<<"表面积为："<<GetArea()<<endl;
}
int main()
{
Circle circle;
();
Rectangle rectangle(3,4);
();
Ball ball;
();
Column column(1,2,3);
();
return 0;
}
运行结果：
代码分析：
实验分析：
1）在主函数中定义两个三角形的类，分别由三条边六个点组成，其中第一组能组成三角形，输出面积，第二组边不能组成三角形输出不能构成三角形；
2）定义点类时，定义两个浮点型数据，用来表示点的坐标，定义边类时定义两个顶点，表示两个端点组成线段，定义三角形类时，用三边表示三角形；
3）三角形的面积用海伦公式求得，在三角形中定义一个判断函数，判断三边能否组成三角形，当能组成三角形时则求面积并输出，当不能组成三角形时，输出不能构成三角形；
三、定义一个基类MyArray，基类中可以存放一组整数，基类中有构造函数、析构函数、输入数据和输出数据的函数。

class MyArray{
public:
MyArray(int leng);
~MyArray{};
void Input();
void Display(string);
protected:
int*alist;
int length;
};
（1）声明一个类SortArray继承类MyArray,在该类中定义一个函数，具有将输入的整数从小到大进行排序的功能。

（2）声明一个类ReArray继承类MyArray,在该类中定义一个函数，具有将输入的整数进行倒置的功能。

（3）声明一个类AverArray继承类MyArray,在该类中定义一个函数，具有求输入的整数平均值的功能。

（4）声明一个NewArray类，同时继承了类SortArray,ReArray和AverArray,使得类NewArray的对象同时具有排序、倒置和求平均值的功
();
();
return 0;
}
实验结果：
结果分析：
定义一个基类，用指针作为数组名，定义一个数组，在定义各个基类，分别实现求平均值，排序，倒置的功能。

在调用成员时由于各个派生类都有基类的成员input，output，故用虚基类，避免出现二异性。

四、队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。

栈具有后进先出的特点，所有入栈的元素都放在栈顶，出栈时栈顶元素先出。

这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。

我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。

这样可以减少代码，提高效率。

设计的基类也可以用于派生出其他类。

本实验要求设计这个基类以及它的两个派生类。

设计基类LinkList，用链表结构实现。

要求链表类具有以下功能：能够在链表的头尾增加节点以及在链表尾增加节点
能够记录链表的个数（用静态成员）
程序分析：
定义基类链表其中包含功能
能够在链表的头尾增加节点以及在链表尾增加节点
能够记录链表的个数（用静态成员）
能返回链表中的节点个数
能查看链表头节点的元素值
能告知链表是否为空
在链表类的构造函数中初始化链表
在链表类的析构函数中释放链表所有元素的空间
定义派生类队与栈，队列初始化用链表的初始化函数，用gettail实现入队操作用gethead实现从队列的头部出对。

栈中初始化用函数puthead实现从栈顶入栈，用函数gethead()实现从栈顶出栈。

三、结论
1）继承可以从基类中获得派生类中不曾定义过的成员，提高了编程效率；2）继承与派生分为共有、私有、保护三种继承方式，其中共有使用最广泛，它使得派生类与基类中的成员具有相同的属性。