第六章实验

实验目的和要求

   了解静态联编的动态联编的概念。  掌握动态联编的条件。

实验内容

1.分析并调试下列程序。 

1. #include<iostream>  

2. using namespace std;  

3. class Base  

4. {  

5.     public:  

6.         virtual void f(float x){cout<<"Base::f(float)"<<x<<endl;}  

7.         void g(float x){cout<<"Base::g(float)"<<x<<endl;}  

8.         void h(float x){cout<<"Base::h(float)"<<x<<endl;}  

9. };  

10. class Derived:public Base  

11. {  

12.    public:  

13.         virtual void f(float x){cout<<"Derived::f(float}"<<x<<endl;}  

14.         void g(int x){cout<<"Derived::g(int)"<<x<<endl;}  

15.         void h(float x){cout<<"Derived::h(float)"<<x<<endl;}  

16. };  

17. int main()  

18. {  

19.     Derived d;  

20.     Base *pb=&d;  

21.     Derived *pd=&d;  

22.     pb->f(3.14f);  

23.     pd->f(3.14f);  

24.     pb->g(3.14f);  

25.     pb->h(3.14f);  

26.     pd->h(3.14f);  

27.     return 0;  

28. }  

（1）找出以上程序中使用了重载和覆盖函数。

       答：Base类中函数void g（）; 和void h（）；与Derived类中的函数void g（）; 和void h（）；函数名相同，参数类型不同，构成了函数重载。

（2）写出程序的输出结果，并解释输出结果。

程序的输出结果如下：

 

2. 分析并调试下列程序

1. #include<iostream>  

2. using namespace std;  

3. class Base  

4. {  

5.     public:  

6.         void f(int x){cout<<"Base::f(int)"<<x<<endl;}  

7.         void f(float x){cout<<"Base::f(float)"<<x<<endl;}  

8.        virtual void g(void){cout<<"Base::g(void)"<<endl;}  

9. };  

10. class Derived:public Base  

11. {  

12.     public:  

13.         virtual void g(void){cout<<"Derived::g(void}"<<endl;}  

14. };  

15. int main()  

16. {  

17.     Derived d;  

18.    Base *pb=&d;  

19.     pb->f(42);  

20.     pb->f(3.14f);  

21.     pb->g();  

22.     return 0;  

23. }  

（1）找出以上程序中使用了重载和覆盖函数。

   答：Base类中函数void f（）; 在同一作用域中，函数名相同，参数类型不同，构成了函数重载。
（2）写出程序的输出结果，并解释输出结果。

程序的输出结果如下：

 

 输出结果分析： pb和pd指向同一地址，它们运行结果应该是相同的，但实际运行出来的结果却不相同，原因是决定pb和pd调用函数运行结果的不是他们指向的地址，而是他们的指针类型。“只有在通过基类指针或引用间接指向派生类子类型时多态性才会起作用”。在程序中pb是基类指针，pd是派生类指针，pd的所有函数调用都只是调用自己的函数，和多态性无关，所以pd的所有函数调用的结果都输出Derived::是完全正常的；pb的函数调用如果有virtual则根据多态性调用派生类的，如果没有virtual则是正常的静态函数调用，还是调用基类的，所以有virtual的f函数调用输出Derived::，其它两个没有virtual则还是输出Base::。

3. 分析并调试下列程序

1. #include<iostream>  

2. using namespace std;  

3. class Point  

4. {  

5.     public:  

6.         Point(double i,double j){x=i;y=j;}  

7.         double Area(){return 0.0;}  

8.     private:  

9.         double x,y;  

10. };  

11. class Rectangle:public Point  

12. {  

13.     public:  

14.        Rectangle(double i,double j,double k,double l):Point(i,j){w=k;h=l;}  

15.         double Area(){return w*h;}  

16.     private:  

17.         double w,h;  

18. };  

19. int main()  

20. {  

21.     Point p(3.5,7);  

22.     double A=p.Area();  

23.     cout<<"Area= "<<A<<endl;  

24.     Rectangle r(1.2,3,5,7.8);  

25.     A=r.Area();  

26.     cout<<"Area= "<<A<<endl;  

27.    return 0;  

28. }  

 

写出程序的输出结果，并解释输出结果。

 

 

4. 分析并调试下列程序

1. #include<iostream>  

2. using namespace std;  

3. const double PI=3.1415;  

4. class Shap  

5. {  

6.     public:  

7.         virtual double Area()=0;  

8. };  

9. class Triangle:public Shap  

10. {  

11.     public:  

12.         Triangle(double h,double w){H=h;W=w;}  

13.        double Area(){return 0.5*H*W;}  

14.     private:  

15.         double H,W;  

16. };  

17. class Rectangle:public Shap  

18. {  

19.   

20.     public:;  

21.         Rectangle(double h,double w){H=h;W=w;}  

22.        double Area(){return H*W;}  

23.     private:  

24.         double H,W;  

25. };  

26. class Circle:public Shap  

27. {  

28.     public:  

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

30.         double Area(){return PI*R*R;}  

31.     private:  

32.         double R;  

33. };  

34. class Square:public Shap  

35. {  

36.     public:  

37.        Square(double s){S=s;}  

38.         double Area(){return S*S;}  

39.     private:  

40.         double S;  

41. };  

42. double Total(Shap *s[],int n)  

43. {  

44.     double sum=0;  

45.     for(int i=0;i<n;i++)  

46.         sum+=s[i]->Area();  

47.     return sum;  

48. }  

49. int main()  

50. {  

51.    Shap *s[5];  

52.    s[0]=new Square(8.0);  

53.    s[1]=new Rectangle(3.0,8.0);  

54.    s[2]=new Square(12.0);  

55.    s[3]=new Circle(8.0);  

56.    s[4]=new Triangle(5.0,4.0);  

57.    double sum=Total(s,5);  

58.    cout<<"SUM = "<<sum<<endl;  

59.     return 0;  

60. }  

 

程序的输出结果如下：

 

（1）指出抽象类。
（2）指出纯虚函数，并说明它的作用。
（3）每个类的作用是什么？整个程序的作用是什么？

5. 某学校对教师每个月工资的计算规定如下：固定工资+课时补贴；教授的固定工资为5000元，每个课时补贴50；副教授的固定工资为3000，每个课时补贴30元；讲师的固定工资为2000元，每个课时补贴20元。定义教师抽象类，派生不同职称的教师类，编写程序求若干个教师的月工资。（sy6_5.cpp) 

1. #include <iostream>  

2. using namespace std;  

3. class Teacher  

4. {  

5. public:  

6.     virtual int Salary()=0;  

7.     virtual void Print(int)=0;  

8. };  

9.   

10. class Professor:public Teacher  

11. {  

12. private:  

13.     char name[128];  

14.     int lessons;  

15. public:  

16.     Professor()  

17.     {  

18.         cout<<"请输入姓名：";  

19.         cin>>name;  

20.         cout<<"请输入课时：";  

21.         cin>>lessons;  

22.     };  

23.     int Salary()  

24.     {  

25.         return (5000+lessons*50);  

26.     };  

27.     void Print(int money)  

28.     {  

29.         cout<<"职称：教授 姓名："<<name<<" 薪水："<<money<<endl<<endl;  

30.     };  

31. };  

32.   

33. class AssociateProfessor:public Teacher  

34. {  

35. private:  

36.     char name[128];  

37.     int lessons;  

38. public:  

39.     AssociateProfessor()  

40.     {  

41.         cout<<"请输入姓名：";  

42.         cin>>name;  

43.         cout<<"请输入课时：";  

44.         cin>>lessons;  

45.     };  

46.     int Salary()  

47.     {  

48.         return (3000+lessons*30);  

49.     };  

50.     void Print(int money)  

51.     {  

52.         cout<<"职称：副教授 姓名："<<name<<" 薪水："<<money<<endl<<endl;  

53.     };  

54. };  

55.   

56. class Lecturer:public Teacher  

57. {  

58. private:  

59.     char name[128];  

60.     int lessons;  

61. public:  

62.     Lecturer()  

63.     {  

64.         cout<<"请输入姓名：";  

65.         cin>>name;  

66.         cout<<"请输入课时：";  

67.         cin>>lessons;  

68.     };  

69.     int Salary()  

70.     {  

71.         return (2000+lessons*20);  

72.     };  

73.     void Print(int money)  

74.     {  

75.         cout<<"职称：讲师 姓名："<<name<<"薪水："<<money<<endl<<endl;  

76.     };  

77. };  

78.   

79. int main()  

80. {  

81.     Teacher *t = NULL;  

82.   

83.     int money=0;  

84.   

85.      t = new Professor();  

86.     money = t->Salary();  

87.     t->Print(money);  

88.     delete t;  

89.   

90.   

91.     t = new AssociateProfessor();  

92.     money = t->Salary();  

93.     t->Print(money);  

94.     delete t;  

95.   

96.   

97.     t = new Lecturer();  

98.     money = t->Salary();  

99.     t->Print(money);  

100.     delete t;  

101.     t = NULL;  

102.     return 0;  

103. }  

运行结果：

 

2.总结静态联编和动态联编的区别和动态联编的条件。

  答：静态联编是指联编工作在编译阶段完成的，这种联编过程是在程序运行之前完成的，又称为早期联编。要实现静态联编，在编译阶段就必须确定程序中的操作调用（如函数调用）与执行该操作代码间的关系，确定这种关系称为束定，在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引用的类型。其优点是效率高，但灵活性差。

    动态联编是指联编在程序运行时动态地进行，根据当时的情况来确定调用哪个同名函数，实际上是在运行时虚函数的实现。这种联编又称为晚期联编，或动态束定。动态联编对成员函数的选择是基于对象的类型，针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编，但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强，但效率低。

       动态联编的条件：必须把动态联编的行为定义为类的虚函数；类之间应满足子类型关系，通常表现为一个类从另一个类公有派生而来；必须先使用基类指针指向子类型的对象，然后直接或者间接使用基类指针调用虚函数。

 

实验总结

  通过本次的学习和实践，我学到了很多知识，比如了解静态联编的动态联编的概念并掌握动态联编的条件；与此同时我还总结出了静态联编和动态联编的区别以及重载与覆盖的区别。通过这些知识的学习与总结让我对于本课程的学习又掌握了一些不同的知识点，扩大了自己学习的范围，为自己及下一步的学习也有了很大的帮助。