实验六

实验目的和要求

    了解静态联编的动态联编的概念。掌握动态联编的条件。
实验内容
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)找出以上程序中使用了重载和覆盖函数。
(2)写出程序的输出结果,并解释输出结果
程序的输出结果如下:
分析:
在程序中pb是基类指针,pd是派生类指针,pd的所有函数调用都只是调用自己的函数

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)找出以上程序中使用了重载和覆盖函数。
(2)写出程序的输出结果,并解释输出结果。
运行结果如下:

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

运行结果如下:

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

分析与讨论

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

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

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

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

        动态联编是指联编在程序运行时动态地进行,根据当时的情况来确定调用哪个同名函数,实际上是在运行时虚函数的实现。这种联编又称为晚期联编,或动态束定。动态联编对成员函数的选择是基于对象的类型,针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编,但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强,但效率低。                                                                                                                                                                     动态联编的条件:
①必须把动态联编的行为定义为类的虚函数。                                                                                                                  
②类之间应满足子类型关系,通常表现为一个类从另一个类公有派生而来。                                                                          
③必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页