您的位置: 首页  >  文章  >  实验五 继承与派生

实验五 继承与派生

分类: 文章 • 2025-04-24 10:49:40

实验目的和要求

1.掌握派生类的定义方法的和派生类构造函数定义方法。

2.掌握在不同继承方式的情况下，基类成员在派生类中的访问权限。

3.掌握在多继承方式的情况下，构造函数与析构函数的调用时机与顺序。

实验内容

1.调试下列程序，并在对程序进行修改后再调试，指出调试中出错原因。

[cpp] view plain copy
  1. //sy5_1.cpp  
  2. #include<iostream>  
  3. using namespace std;  
  4. class A  
  5. {  
  6. public:  
  7.    void seta(int i){a=i;}  
  8.    int geta(){return a;}  
  9. public:  
  10.     int a;  
  11. };  
  12. class B:public A  
  13. {  
  14. public:  
  15.     void setb(int i){b=i;}  
  16.     int getb(){return b;}  
  17.     void show(){cout<<"A::a="<<a<<endl;}  
  18. public:  
  19.     int b;  
  20. };  
  21. int main()  
  22. {  
  23.    B bb;  
  24.    bb.seta(6);  
  25.    bb.setb(3);  
  26.    bb.show();  
  27.    cout<<"A::a="<<bb.a<<endl;  
  28.    cout<<"B::b="<<bb.b<<endl;  
  29.    cout<<"A::a="<<bb.geta()<<endl;  
  30.    cout<<"B::b="<<bb.getb()<<endl;  
  31.    return 0;  
  32. }  
运行结果：
实验五 继承与派生

按下列要求对程序进行修改，然后调试，对出现的错误分析其原因。

（1）将派生类B的继承方式改为private时，会出现哪些错误和不正常现象？为什么？

   答：将派生类B的继承方式改为private时，编译程序指出语句2、语句5、语句7有错。这是因为当类的继承方式为私有继承时，基类A的公有成员函数a，公有成员函数seta（）和geta（）作为派生类B的私有成员，派生类成员可以直接访问它们，但在类外部，派生类的对象无法访问它们。

（2）将派生类B的继承方式改为protected时，会出现哪些错误和不正常现象？为什么？

   答：将派生类B的继承方式改为protected时，编译程序指出语句2、语句5、语句7有错。这是因为当类的继承方式为保护继承时，基类A的公有数据成员a，公有成员函数seta（）和geta（）作为派生类B的保护成员，派生类成员可以直接访问它们，但在类外部，派生类的对象无法访问它们。

（3）将派生类B的继承方式恢复为public，再将类A中的数据成员int型变量a的访问权限改为private时，会出现哪些错误和不正常现象？为什么？

   答：主函数中的语句5、语句9出现了错误；因为B采用的是公有继承，所以B中和主函数中不能访问A中的私有函数。

（4）派生类B的继承方式仍为public，将类A中的数据成员int型变量a的访问权限改为protected时，会出现哪些错误和不正常现象？为什么？

         答：主函数中的语句5出现了错误；因为B采用公有继承，所以A中保护成员在B中仍为保护成员，B中可以访问A中的保护成员，但不能通过类的对象访问类的保护成员。


2.重写教材中的Li4_10.cpp，给每个类增加一个析构函数，并使类之间的关系如附图1所示，再写出程序的输出结果。（sy5_2.cpp）

 实验五 继承与派生

                        附图1   类之间的关系

修改程序如下：

 

[cpp] view plain copy
  1. //sy5_2.cpp  
  2. #include<iostream>  
  3. using namespace std;  
  4. class Base1  
  5. {  
  6. public:  
  7.    Base1(){cout<<"constructing Base1"<<endl;}  
  8.    ~Base1(){cout<<"destructing Base1"<<endl;}  
  9. };  
  10. class Base2  
  11. {  
  12.     public:  
  13.       Base2(){cout<<"constructing Base2"<<endl;}  
  14.      ~Base2(){cout<<"destructing Base2"<<endl;}  
  15. };  
  16. class Derived1:public Base2,virtual public Base1  
  17. {  
  18.     public:  
  19.     Derived1(){cout<<"constructing Derived1"<<endl;}  
  20.     ~Derived1(){cout<<"destructing Derived1"<<endl;}  
  21. };  
  22. class Derived2:public Base2,virtual public Base1  
  23. {  
  24.     public:  
  25.     Derived2(){cout<<"constructing Derived2"<<endl;}  
  26.     ~Derived2(){cout<<"destructing Derived2"<<endl;}  
  27. };  
  28. class Derived3:public Derived1,virtual public Derived2  
  29. {  
  30.     public:  
  31.     Derived3(){cout<<"constructing Derived3"<<endl;}  
  32.     ~Derived3(){cout<<"destructing Derived3"<<endl;}  
  33. };  
  34. int main()  
  35. {  
  36.    Derived3 obj;  
  37.    return 0;  
  38. }  

程序输出结果如下:

实验五 继承与派生 


3. 利用继承性与派生类来管理学生和教师的档案。假设要管理下述几类人员的如下一些数据。

   teacher（教师）类：姓名、性别、年龄、学号、系别；

   gradstudent（研究生）类：姓名、性别、年龄、学号、系别、导师；

  要求每个类只设立构造函数以及显示类对象数据的成员函数。编写主函数，说明有关类对象，并对其类成员函数进行简单使用。（sy5_3.cpp）

编写程序如下：
[cpp] view plain copy
  1. #include<iostream>  
  2. #include<string>  
  3. using namespace std;  
  4. class teacher{  
  5.     public:  
  6.         teacher(string name,char sex,int age,string title,string course)  
  7.          {  
  8.              nam=name;  
  9.              s=sex;  
  10.              a=age;  
  11.              t=title;  
  12.              c=course;  
  13.         }  
  14.         void print()  
  15.         {  
  16.             cout<<"name: "<<nam<<endl;  
  17.             cout<<"sex: "<<s<<endl;  
  18.             cout<<"age: "<<a<<endl;  
  19.             cout<<"title: "<<t<<endl;  
  20.             cout<<"course: "<<c<<endl;  
  21.         }  
  22.         protected:  
  23.              string nam;  
  24.               char s;  
  25.               int a;  
  26.               string t;  
  27.               string c;  
  28.               };  
  29.     class student{  
  30.         public:  
  31.             student(string name,char sex,int age,int number, string department)  
  32.              {  
  33.                  nam=name;  
  34.                  s=sex;  
  35.                  a=age;  
  36.                  num=number;  
  37.                  dep=department;  
  38.             }  
  39.     void print()  
  40.     {  
  41.          cout<<"name: "<<nam<<endl;  
  42.          cout<<"sex: "<<s<<endl;  
  43.          cout<<"age: "<<a<<endl;  
  44.          cout<<"number: "<<num<<endl;  
  45.          cout<<"department: "<<dep<<endl;  
  46.     }  
  47.       protected:  
  48.            string nam;  
  49.            char s;  
  50.            int a;  
  51.            int num;  
  52.            string dep;  
  53.         };  
  54.     class gradstudent:public student  
  55.     {  
  56.         public:  
  57.             gradstudent(string name,char sex,int age,int number, string department,string professor):student(name,sex,age,number,department)  
  58.             {  
  59.                  pro=professor;  
  60.             }  
  61.         void print()  
  62.         {  
  63.             cout<<"name: "<<nam<<endl;  
  64.             cout<<"sex: "<<s<<endl;  
  65.             cout<<"age: "<<a<<endl;  
  66.             cout<<"number: "<<num<<endl;  
  67.             cout<<"department: "<<dep<<endl;  
  68.             cout<<"professor: "<<pro<<endl;  
  69.             }  
  70.         private:  
  71.             string pro;  
  72.             };  
  73.     int main()  
  74.     {  
  75.          cout<<"*********************************************"<<endl;  
  76.          cout<<"******欢迎您来到学生和教师档案查询系统*******"<<endl;  
  77.          cout<<"*********************************************"<<endl;  
  78.           int i,j;  
  79.           teacher teac("shishuaishuai",'m',27,"js","mxdx");  
  80.           student stu("liendan",'w',22,22,"computer");  
  81.           gradstudent grad("chengkai",'m',25,12,"computer","hzp");  
  82.           cout<<endl;  
  83.           loop:cout<<"请输入你要查询的对象："<<endl<<"1.教师; 2.学生; 3.研究生。"<<endl;  
  84.           {  
  85.               cin>>i; if(i==1)teac.print();  
  86.               else if(i==2) stu.print();  
  87.               else grad.print();  
  88.          }  
  89.             cout<<endl;  
  90.             cout<<"是否继续查询？ 1.yes 2.no"<<endl; cin>>j;  
  91.             if(j==1) goto loop;  
  92.              else return 0;  
  93. }  

[cpp] view plain copy
  1.   

程序输出结果如下：

实验五 继承与派生

4.试写出所能想到的所有形状（包括二维的和三维的），生成一个形状层次类结构。生成的层次结构一Shape作为基类，并由此派生出TwoDimShape类和ThreeDimShape类。它们的派生类是不同形状类，定义层次结构中的每一个类，并用函数main（）进行测试。（sy5_4.cpp）

编写程序如下：

[cpp] view plain copy
  1. //sy5_4.cpp  
  2. #include<iostream>  
  3. using namespace std;  
  4. class Shape  
  5. {  
  6. public:  
  7.    Shape(){};  
  8.    double area() const{return 0.0;}  
  9.    double bulk() const{return 0.0;}  
  10. };  
  11. class TwoDimShape:public Shape{};  
  12. class Circle:public TwoDimShape  
  13. {  
  14.     public:  
  15.     Circle(double r){R=r;}  
  16.     double area()const{return 3.14*R*R;}  
  17.     protected:  
  18.     double R;  
  19. };  
  20. class ThreeDimShape:public Shape{};  
  21. class sphere:public ThreeDimShape  
  22. {  
  23.     public:  
  24.     sphere(double w){R=w;}  
  25.     double bulk()const{return 4/3*3.14*R*R*R;}  
  26.     protected:  
  27.     double R;  
  28. };  
  29. int main()  
  30. {  
  31.     Shape sha;  
  32.     double area;  
  33.     double bulk;  
  34.     Circle c(7.0);  
  35.     area=c.area();  
  36.     cout<<"Area of circle is "<<area<<endl;  
  37.     sphere sph(9.0);  
  38.     bulk=sph.bulk();  
  39.     cout<<"Bulk of sphere is "<<bulk<<endl;  
  40.    return 0;  
  41. }  

程序输出结果如下：

 实验五 继承与派生

分析与讨论

1.通过对实验内容中第1题的调试，总结不同继承方式的情况下，基类成员在派生类中的访问权限。

        答：当类的继承方式为公有继承时，在派生类中，基类的公有成员和保护成员被继承后分别作为派生类的公有成员和保护成员，这样使得派生类的成员函数可以直接访问它们，而派生类成员函数无法直接访问基类的私有成员。在类的外部，派生了的对象可以访问继承下来的基类公有成员。                      当类的继承方式为私有继承时，在派生类中，基类的公有成员和保护成员作为派生类的私有成员，派生类的成员函数可以直接访问它们，而派生类的成员函数无法直接访问基类的私有成员。在类外部，派生类的对象无法访问基类的所有成员。
     当类的继承方式为保护继承时，在派生类中，基类的公有成员和保护成员作为派生类的保护成员，派生类的成员函数可以直接访问它们，而派生类的成员函数无法直接访问基类的私有成员。在类外部，派生类的对象无法基类的所有成员。

2.解释实验内容第2题的运行结果，总结多继承方式的情况下，构造函数与析构函数的调用时机与顺序。虚基类的构造函数与普通基类的构造函数在调用时有什么不同？

      答：构造函数的调用顺序：先调用所有基类的构造函数，再调用派生类中子对象类的构造函数（如果派生类中没有子对象），最后调用派生类的构造函数。

     虚基类的构造函数的调用顺序：遵循两个原则，而且按顺序优先满足：1 先调用完所以基类，再调用子类；2 先调用虚拟基类，再调用非虚拟基类，一旦调用了虚拟基类的构造函数，则非虚拟基类构造函数就按照声明的顺序被调用。

     普通基类的构造函数：虚基类构造函数、普通基类构造函数、子类构造函数和其他（从左至右依次执行）。

3.如果希望附图1中的Base1、Base2均有两个，如何修改顺序？



 实验总结：

     通过本章的学习了解类的继承，三种继承方式的区别，以及通过参数列表对派生类的成员赋值的方法，即调用基类构造函数后再对新增成员赋值。

相关推荐