[已解决]一道静态联编和动态联编的题

QQQin

【问题描述】某学校对教师每个月工资的计算规定如下：固定工资+课时补贴；教授的固定工资为5000元，每个课时补贴50；副教授的固定工资为3000，每个课时补贴30元。教师类作为基类已经定义好，你需要编写教师类的派生类教授和副教授，以实现主函数中的输出。
【样例输入】zheng 20 duan 30
【样例输出】
Title: Pro. Name: zheng Salary: 6000
Title: A.P. Name: duan Salary: 3900
Title: A.P. Name: duan Salary: 3900
【评分标准】5个测试用例，每个占20%

//第8次作业，虚函数
#include  <iostream>
#include  <string.h>
using  namespace  std;

class  Teacher
{
public:
        virtual  int  Salary()=0;
        virtual  void  Print(int)=0;
};













int  main()
{
        Teacher  *t;
        int  money=0;
        char  pro_name[128];   
        char  ap_name[128];
        int  pro_lessons,  ap_lessons;
        cin  >>  pro_name  >>  pro_lessons  >>  ap_name  >>  ap_lessons;
         
        Professor  p(pro_name,  pro_lessons);
        t  =  &p;
        money  =  t->Salary();
        t->Print(money);
   
        AssociateProfessor  aprof(ap_name,  ap_lessons);
        //  静态联编
        money  =  aprof.Salary();
        aprof.Print(money);
        //  动态联编
          t  =  &aprof;
        money  =  t->Salary();
        t->Print(money);
   
        t  =  NULL;
        system("pause");
        return  0;
}
请问我写的时候报错说函数调用缺少参数列表；请使用“&Professor::Salary”创建指向成员的指针以及其他，那么到底怎么去实现这个派生类呢？

最佳答案

月排行榜 / 总排行榜

JLDawson

2020-4-21 15:39:10

QQQin 发表于 2020-4-21 16:36
还有一个问题，受时间限制不能发，在这里想请您帮忙看一下

要求输出格式是

这个比较简单。楼主自己试试应该可以写出来吧

1. int main()
   
2. {
   
3.         Student stu1(0);                        //Constructor
   
4.         cout << "stu1" << endl;                //stu1
   
5.         stu1.print();                                //0
   
6.         stu1.print(stu1);                        //Copy Function                        0                        Destructor
   
7. 
   
8.         cout << "stu2" << endl;                                //stu2
   
9.         Student *stu2 = new Student(1);                //Constructor
   
10.         stu2->print();                                                //1
    
11.         delete stu2;                                                //Destructor
    
12. 
    
13. 
    
14.         Student stu3(stu1);                                        //Copy Function
    
15.         cout << "stu3" << endl;                                //stu3
    
16.         stu3.print();                                                //0
    
17.         stu3.print(stu3);                                        //Copy Function                        0                        Destructor
    
18. 
    
19.         return 0;                                                //运行到此处再步进调试，则可以看到最后俩个Destructor。依次析构stu3和stu1。此处析构顺序牵扯到栈，自行查阅知识点
    
20. }

复制代码

跳转到最佳答案楼层

JLDawson

QQQin 发表于 2020-4-21 16:36
还有一个问题，受时间限制不能发，在这里想请您帮忙看一下

要求输出格式是

这个比较简单。楼主自己试试应该可以写出来吧

1. int main()
   
2. {
   
3.         Student stu1(0);                        //Constructor
   
4.         cout << "stu1" << endl;                //stu1
   
5.         stu1.print();                                //0
   
6.         stu1.print(stu1);                        //Copy Function                        0                        Destructor
   
7. 
   
8.         cout << "stu2" << endl;                                //stu2
   
9.         Student *stu2 = new Student(1);                //Constructor
   
10.         stu2->print();                                                //1
    
11.         delete stu2;                                                //Destructor
    
12. 
    
13. 
    
14.         Student stu3(stu1);                                        //Copy Function
    
15.         cout << "stu3" << endl;                                //stu3
    
16.         stu3.print();                                                //0
    
17.         stu3.print(stu3);                                        //Copy Function                        0                        Destructor
    
18. 
    
19.         return 0;                                                //运行到此处再步进调试，则可以看到最后俩个Destructor。依次析构stu3和stu1。此处析构顺序牵扯到栈，自行查阅知识点
    
20. }

复制代码

JLDawson

思路：Professor 和AssociateProfessor继承 Teacher，完成构造和析构函数，然后重写其纯虚函数。
代码如下：

1. #include  <iostream>
   
2. #include  <string.h>
   
3. using  namespace  std;
   
4. 
   
5. class  Teacher
   
6. {
   
7. public:
   
8.         virtual  int  Salary() = 0;
   
9.         virtual  void  Print(int) = 0;
   
10. };
    
11. 
    
12. class Professor :public Teacher {
    
13. public:
    
14.         Professor(char *pName, int nlessons)
    
15.                 : pName(pName)
    
16.                 , nLessons(nlessons)
    
17.         {
    
18.                 if (pName)
    
19.                 {
    
20.                         int nLen = strlen(pName);
    
21.                         this->pName = new char[nLen+1];
    
22.                         strcpy(this->pName, pName);
    
23.                 }
    
24.         }
    
25. 
    
26.         ~Professor() {
    
27.                 if (pName)
    
28.                 {
    
29.                         delete pName;
    
30.                 }
    
31.         }
    
32. 
    
33.         int  Salary() override{
    
34.                 int nMoney = 5000 + nLessons * 50;
    
35.                 return nMoney;
    
36.         }
    
37. 
    
38.         void  Print(int money) override {
    
39.                 if (pName)
    
40.                 {
    
41.                         cout << "Title: Pro.Name :" << pName <<  " Salary :" << money << endl;
    
42.                 }
    
43.         }
    
44. 
    
45. private:
    
46.         char *pName;
    
47.         int nLessons;
    
48. };
    
49. 
    
50. class AssociateProfessor :public Teacher {
    
51. public:
    
52.         AssociateProfessor(char *pName, int nlessons)
    
53.                 : pName(pName)
    
54.                 , nLessons(nlessons)
    
55.         {
    
56.                 if (pName)
    
57.                 {
    
58.                         int nLen = strlen(pName);
    
59.                         this->pName = new char[nLen + 1];
    
60.                         strcpy(this->pName, pName);
    
61.                 }
    
62.         }
    
63. 
    
64.         ~AssociateProfessor() {
    
65.                 if (pName)
    
66.                 {
    
67.                         delete pName;
    
68.                 }
    
69.         }
    
70. 
    
71.         int  Salary() override {
    
72.                 int nMoney = 3000 + nLessons * 30;
    
73.                 return nMoney;
    
74.         }
    
75. 
    
76.         void  Print(int money) override {
    
77.                 if (pName)
    
78.                 {
    
79.                         cout << "Title: A.P.Name :" << pName << " Salary :" << money << endl;
    
80.                 }
    
81.         }
    
82. 
    
83. private:
    
84.         char *pName;
    
85.         int nLessons;
    
86. };
    
87. 
    
88. int  main()
    
89. {
    
90.         Teacher  *t;
    
91.         int  money = 0;
    
92.         char  pro_name[128];
    
93.         char  ap_name[128];
    
94.         int  pro_lessons, ap_lessons;
    
95.         cin >> pro_name >> pro_lessons >> ap_name >> ap_lessons;
    
96. 
    
97.         Professor  p(pro_name, pro_lessons);
    
98.         t = &p;
    
99.         money = t->Salary();
    
100.         t->Print(money);
     
101. 
     
102.         AssociateProfessor  aprof(ap_name, ap_lessons);
     
103.         //  静态联编
     
104.         money = aprof.Salary();
     
105.         aprof.Print(money);
     
106.         //  动态联编
     
107.         t = &aprof;
     
108.         money = t->Salary();
     
109.         t->Print(money);
     
110. 
     
111.         t = NULL;
     
112.         system("pause");
     
113.         return  0;
     
114. }

复制代码

QQQin

JLDawson 发表于 2020-4-21 16:31
思路：Professor 和AssociateProfessor继承 Teacher，完成构造和析构函数，然后重写其纯虚函数。
代码如下 ...

还有一个问题，受时间限制不能发，在这里想请您帮忙看一下

1. #include  <iostream>
   
2.    
   
3. using  namespace  std;
   
4. class  Student
   
5. {
   
6. private:
   
7.         int  id;
   
8.    
   
9. public:
   
10.         Student(const  int  a)  {   
    
11.                 id  =  a;   
    
12.                 cout<<"Constructor"<<endl;
    
13.         }
    
14.                                                                                                                                  
    
15.         Student(const  Student  &  stu)  {
    
16.                 id  =  stu.id;   
    
17.                 cout<<"Copy  Function"<<endl;
    
18.         }   
    
19. 
    
20.         ~Student()  {   
    
21.                 cout<<"Destructor"<<endl;   
    
22.         }   
    
23.    
    
24.         void  print(Student  stu){                                                                     
    
25.                 cout<<stu.id<<endl;
    
26.         }
    
27.         void  print(){
    
28.                 cout<<id<<endl;
    
29.         }
    
30.         friend  void  print1(Student  stu);   
    
31. };
    
32. 
    
33. void  print1(Student  stu){     
    
34.         cout<<stu.id<<endl;
    
35. }

复制代码

要求输出格式是

1. Constructor
   
2. stu1
   
3. 0
   
4. Copy Function
   
5. 0
   
6. Destructor
   
7. stu2
   
8. Constructor
   
9. 1
   
10. Destructor
    
11. Copy Function
    
12. stu3
    
13. 0
    
14. Copy Function
    
15. 0
    
16. Destructor
    
17. Destructor
    
18. Destructor

复制代码

编写主函数输出的时候我输出的有四个Destructor，请问是因为什么？怎么去写这个主函数呢？