博客

实验六 多态性与虚函数

  • Post author:
  • Post category:其他



一、实验目的和要求




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




二、实验内容


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

[cpp]

view plain


copy



  1. //sy6_1.cpp


  2. #include<iostream>


  3. using




    namespace


    std;


  4. class


    Base

  5. {


  6. public


    :


  7. virtual




    void


    f(


    float


    x){cout<<


    “Base::f(float)”


    <<x<<endl;}


  8. void


    g(


    float


    x){cout<<


    “Base::g(float)”


    <<x<<endl;}


  9. void


    h(


    float


    x){cout<<


    “Base::h(float)”


    <<x<<endl;}

  10. };


  11. class


    Derived:


    public


    Base

  12. {


  13. public


    :


  14. virtual




    void


    f(


    float


    x){cout<<


    “Derived::f(float}”


    <<x<<endl;}


  15. void


    g(


    int


    x){cout<<


    “Derived::g(int)”


    <<x<<endl;}


  16. void


    h(


    float


    x){cout<<


    “Derived::h(float)”


    <<x<<endl;}

  17. };


  18. int


    main()

  19. {

  20. Derived d;

  21. Base *pb=&d;

  22. Derived *pd=&d;

  23. pb->f(3.14f);

  24. pd->f(3.14f);

  25. pb->g(3.14f);

  26. pb->h(3.14f);

  27. pd->h(3.14f);


  28. return


    0;

  29. }


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


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

程序运行结果如下：

解释输出结果：

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

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. //sy6_3.cpp


  2. #include<iostream>


  3. using




    namespace


    std;


  4. class


    Point

  5. {


  6. public


    :

  7. Point(

    double


    i,


    double


    j){x=i;y=j;}


  8. double


    Area(){



    return


    0.0;}


  9. private


    :


  10. double


    x,y;

  11. };


  12. class


    Rectangle:


    public


    Point

  13. {


  14. public


    :

  15. Rectangle(

    double


    i,


    double


    j,


    double


    k,


    double


    l):Point(i,j){w=k;h=l;}


  16. double


    Area(){



    return


    w*h;}


  17. private


    :


  18. double


    w,h;

  19. };


  20. int


    main()

  21. {

  22. Point p(3.5,7);


  23. double


    A=p.Area();

  24. cout<<

    “Area= ”


    <<A<<endl;

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

  26. A=r.Area();

  27. cout<<

    “Area= ”


    <<A<<endl;


  28. return


    0;

  29. }

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

输出结果如下：


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

[cpp]

view plain


copy



  1. //sy6_4.cpp


  2. #include<iostream>


  3. using




    namespace


    std;


  4. const




    double


    PI=3.1415;


  5. class


    Shap

  6. {


  7. public


    :


  8. virtual




    double


    Area()=0;

  9. };


  10. class


    Triangle:


    public


    Shap

  11. {


  12. public


    :

  13. Triangle(

    double


    h,


    double


    w){H=h;W=w;}


  14. double


    Area(){



    return


    0.5*H*W;}


  15. private


    :


  16. double


    H,W;

  17. };


  18. class


    Rectangle:


    public


    Shap

  19. {



  21. public


    :;

  22. Rectangle(

    double


    h,


    double


    w){H=h;W=w;}


  23. double


    Area(){



    return


    H*W;}


  24. private


    :


  25. double


    H,W;

  26. };


  27. class


    Circle:


    public


    Shap

  28. {


  29. public


    :

  30. Circle(

    double


    r){R=r;}


  31. double


    Area(){



    return


    PI*R*R;}


  32. private


    :


  33. double


    R;

  34. };


  35. class


    Square:


    public


    Shap

  36. {


  37. public


    :

  38. Square(

    double


    s){S=s;}


  39. double


    Area(){



    return


    S*S;}


  40. private


    :


  41. double


    S;

  42. };


  43. double


    Total(Shap *s[],


    int


    n)

  44. {


  45. double


    sum=0;


  46. for


    (


    int


    i=0;i<n;i++)

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


  48. return


    sum;

  49. }


  50. int


    main()

  51. {

  52. Shap *s[5];

  53. s[0]=

    new


    Square(8.0);

  54. s[1]=

    new


    Rectangle(3.0,8.0);

  55. s[2]=

    new


    Square(12.0);

  56. s[3]=

    new


    Circle(8.0);

  57. s[4]=

    new


    Triangle(5.0,4.0);


  58. double


    sum=Total(s,5);

  59. cout<<

    “SUM = ”


    <<sum<<endl;


  60. return


    0;

  61. }

运行结果如下：


（1）指出抽象类。

（2）指出纯虚函数，并说明它的作用。

（3）每个类的作用是什么？整个程序的作用是什么？

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

编写程序如下：

[cpp]

view plain


copy



  1. //sy6_5.cpp


  2. #include <iostream>


  3. using




    namespace


    std;


  4. class


    Teacher

  5. {


  6. public


    :


  7. virtual




    int


    Salary()=0;


  8. virtual




    void


    Print(


    int


    )=0;

  9. };



  11. class


    Professor:


    public


    Teacher

  12. {


  13. private


    :


  14. char


    name[128];


  15. int


    lessons;


  16. public


    :

  17. Professor()

  18. {

  19. cout<<

    “请输入姓名：”


    ;

  20. cin>>name;

    //字符串中不能有空格

  21. cout<<

    “请输入课时：”


    ;

  22. cin>>lessons;

    //必须输入数字

  23. };


  24. int


    Salary()

  25. {


  26. return


    (5000+lessons*50);

  27. };


  28. void


    Print(


    int


    money)

  29. {

  30. cout<<

    “职称：教授 姓名：”


    <<name<<


    ” 薪水：”


    <<money<<endl<<endl;

  31. };

  32. };



  34. class


    AssociateProfessor:


    public


    Teacher

  35. {


  36. private


    :


  37. char


    name[128];


  38. int


    lessons;


  39. public


    :

  40. AssociateProfessor()

  41. {

  42. cout<<

    “请输入姓名：”


    ;

  43. cin>>name;

  44. cout<<

    “请输入课时：”


    ;

  45. cin>>lessons;

  46. };


  47. int


    Salary()

  48. {


  49. return


    (3000+lessons*30);

  50. };


  51. void


    Print(


    int


    money)

  52. {

  53. cout<<

    “职称：副教授 姓名：”


    <<name<<


    ” 薪水：”


    <<money<<endl<<endl;

  54. };

  55. };



  57. class


    Lecturer:


    public


    Teacher

  58. {


  59. private


    :


  60. char


    name[128];


  61. int


    lessons;


  62. public


    :

  63. Lecturer()

  64. {

  65. cout<<

    “请输入姓名：”


    ;

  66. cin>>name;

  67. cout<<

    “请输入课时：”


    ;

  68. cin>>lessons;

  69. };


  70. int


    Salary()

  71. {


  72. return


    (2000+lessons*20);

  73. };


  74. void


    Print(


    int


    money)

  75. {

  76. cout<<

    “职称：讲师 姓名：”


    <<name<<


    “薪水：”


    <<money<<endl<<endl;

  77. };

  78. };



  80. int


    main()

  81. {

  82. Teacher *t = NULL;



  84. int


    money=0;


  85. //教授

  86. t =

    new


    Professor();

  87. money = t->Salary();

  88. t->Print(money);


  89. delete


    t;



  91. //副教授

  92. t =

    new


    AssociateProfessor();

  93. money = t->Salary();

  94. t->Print(money);


  95. delete


    t;



  97. //讲师

  98. t =

    new


    Lecturer();

  99. money = t->Salary();

  100. t->Print(money);


  101. delete


    t;

  102. t = NULL;


  103. return


    0;

  104. }

程序运行结果如下：


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


三、分析与讨论

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


版权声明：本文为qq_41798905原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。