第六次实验

实验目的和要求

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

实验内容

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

[cpp]  view plain  copy

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）找出以上程序中使用了重载和覆盖函数。
（2）写出程序的输出结果，并解释输出结果。

程序的输出结果如下：

分析：

在程序中pb是基类指针，pd是派生类指针，pd的所有函数调用都只是调用自己的函数

2. 分析并调试下列程序

[cpp]  view plain  copy

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）找出以上程序中使用了重载和覆盖函数。

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

运行结果如下：

3. 分析并调试下列程序

程序如下：

[cpp]  view plain  copy

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. 分析并调试下列程序

程序如下：

[cpp]  view plain  copy

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)

[cpp]  view plain  copy

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

运行结果如下：

6. 把实验5中的第4题的Shape类定义为抽象类，提供共同操作界面的纯虚函数。TwoDimShape类和ThreeDimShape类仍然抽象类，第3层具体类才能提供全部函数的实现。在测试函数中，使用基类指针实现不同派生类对象的操作。

分析与讨论

1.结合实验内容中第1题和第2题，说明重载与覆盖的区别。

      答：重载与覆盖的区别：1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。3、覆盖要求参数列表相同；重载要求参数列表不同。4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

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

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

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

①必须把动态联编的行为定义为类的虚函数。                                                                                                                  

②类之间应满足子类型关系，通常表现为一个类从另一个类公有派生而来。                                                                          

③必须先使用基类指针指向子类型的对象，然后直接或者间接使用基类指针调用虚函数。