第五章实验

实验目的和要求

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

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

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

实验内容

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

1. #include<iostream>  

2. using namespace std;  

3. class A  

4. {  

5. public:  

6.    void seta(int i){a=i;}  

7.    int geta(){return a;}  

8. public:  

9.     int a;  

10. };  

11. class B:public A  

12. {  

13. public:  

14.     void setb(int i){b=i;}  

15.     int getb(){return b;}  

16.     void show(){cout<<"A::a="<<a<<endl;}  

17. public:  

18.     int b;  

19. };  

20. int main()  

21. {  

22.    B bb;  

23.    bb.seta(6);  

24.    bb.setb(3);  

25.    bb.show();  

26.    cout<<"A::a="<<bb.a<<endl;  

27.    cout<<"B::b="<<bb.b<<endl;  

28.    cout<<"A::a="<<bb.geta()<<endl;  

29.    cout<<"B::b="<<bb.getb()<<endl;  

30.    return 0;  

31. }  

运行结果：

 

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

（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   类之间的关系

修改程序如下： 

1. #include<iostream>  

2. using namespace std;  

3. class Base1  

4. {  

5. public:  

6.    Base1(){cout<<"constructing Base1"<<endl;}  

7.    ~Base1(){cout<<"destructing Base1"<<endl;}  

8. };  

9. class Base2  

10. {  

11.     public:  

12.       Base2(){cout<<"constructing Base2"<<endl;}  

13.      ~Base2(){cout<<"destructing Base2"<<endl;}  

14. };  

15. class Derived1:public Base2,virtual public Base1  

16. {  

17.     public:  

18.     Derived1(){cout<<"constructing Derived1"<<endl;}  

19.     ~Derived1(){cout<<"destructing Derived1"<<endl;}  

20. };  

21. class Derived2:public Base2,virtual public Base1  

22. {  

23.     public:  

24.     Derived2(){cout<<"constructing Derived2"<<endl;}  

25.     ~Derived2(){cout<<"destructing Derived2"<<endl;}  

26. };  

27. class Derived3:public Derived1,virtual public Derived2  

28. {  

29.     public:  

30.     Derived3(){cout<<"constructing Derived3"<<endl;}  

31.     ~Derived3(){cout<<"destructing Derived3"<<endl;}  

32. };  

33. int main()  

34. {  

35.    Derived3 obj;  

36.    return 0;  

37. }  

 

程序输出结果如下:

 

 

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

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

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

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

编写程序如下：

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. }    

程序输出结果如下：

 

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

编写程序如下：

1. #include<iostream>  

2. using namespace std;  

3. class Shape  

4. {  

5. public:  

6.    Shape(){};  

7.    double area() const{return 0.0;}  

8.    double bulk() const{return 0.0;}  

9. };  

10. class TwoDimShape:public Shape{};  

11. class Circle:public TwoDimShape  

12. {  

13.     public:  

14.     Circle(double r){R=r;}  

15.     double area()const{return 3.14*R*R;}  

16.     protected:  

17.     double R;  

18. };  

19. class ThreeDimShape:public Shape{};  

20. class sphere:public ThreeDimShape  

21. {  

22.     public:  

23.     sphere(double w){R=w;}  

24.     double bulk()const{return 4/3*3.14*R*R*R;}  

25.     protected:  

26.     double R;  

27. };  

28. int main()  

29. {  

30.     Shape sha;  

31.     double area;  

32.     double bulk;  

33.     Circle c(7.0);  

34.     area=c.area();  

35.     cout<<"Area of circle is "<<area<<endl;  

36.     sphere sph(9.0);  

37.     bulk=sph.bulk();  

38.     cout<<"Bulk of sphere is "<<bulk<<endl;  

39.    return 0;  

40. }  

 

程序输出结果如下：

 

分析与讨论

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

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

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

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

     虚基类的构造函数的调用顺序：遵循两个原则，而且按顺序优先满足：1 先调用完所以基类，再调用子类；

2 先调用虚拟基类，再调用非虚拟基类，一旦调用了虚拟基类的构造函数，则非虚拟基类构造函数就按照声明的顺序被调用。

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

 

 

 实验总结：

     通过本章的学习了解类的继承，三种继承方式的区别，以及通过参数列表对派生类的成员赋值的方法，即调用基类构造函数后再对新增成员赋值，虚基类的使用时为了对基类数据保存一份拷贝，应注意的是在基类其他的直接派生类继承时也应声明是虚基类，多重继承时的应注意构造函数赋值的规律；只是在本次实验的操作过程中还是存在了很多的问题需要我们认真的去学习和思考，同时也让我意识到自己对于本次的实验中的一些知识点还没有掌握好，需要自己在课下多花时间来学习。