C++编程题 关于 继承和多态 的

Posted 2023-05-08

继承和多态
（1）有一个工厂有三类人：固定工资工人、计件工人、计时工人。
（2）他们有共同的特征：都有名字、住址。
（3）三类员工的工资计算方法不同：固定工资工人，每个月领的工资是不变的；计件工人根据生产的产品数量计算工资；计时工人根据工作的时间长短计算工资。
（4）在main函数中创建不同的员工，并依次输出每个员工的名字、住址、工资等信息。
（5）程序能体现多态。

首先你的第一个问题，d.vf2();这里涉及到一个c++的原则，子类有父类的同名函数，如果不是虚函数的话，则会“隐藏”父类的函数，不管参数是否一致，都会隐藏！所以你的dd::vf2(int
i)这个函数就把bb::vf2()隐藏了，因此dd就不会继承这个函数。至于为什么这么设计，以前貌似看某处b.s的访谈，说为了减小出错的几率，以免子类的使用者不小心误使用了父类的函数。
看起来貌似第二个问题和第一个问题是一样的，但是结果却不同，其实你应该去了解下c++的对象模型，你就知道它的运作机理了。
对于虚函数，是动态绑定的，在对象内部有一个虚函数表，表里面是一个个的函数指针，指向当前对象的各个虚函数真正的代码，当你代码执行到调用虚函数那里的时候，会去这个表里面查，然后取出函数指针再调用。
如果是非虚函数，则是静态绑定的，也就是说在编译的时候就已经确定要调用哪个函数！
不管b::vf2、d::vf2、d::vf3都是非虚函数，都会发生静态绑定。
也就是说编译器在编译代码的时候就会决定到底调用哪个函数。它怎么决定呢？看类型。如下：
bp->vf2();
//这句话，编译器看到了bp是b*类型的，于是就去找b::vf2()这个函数，找到了于是绑定成功。
d.vf2();
//这句话，编译器看到d是d类型的，于是去找d::vf2()这个函数，由于上面提到的隐藏原则，d不存在这个函数，于是没找到，出错。
dp->vf2();
//这句话，编译器看到dp是d*类型的，去找d::vf2()这个函数，于是同上，找不到，出错。
dp->vf3();//编译器看到dp是d*类型的，于是找d::vf3()这个函数，找到了，于是绑定成功。
分析完这四句编译器的行为，你就明白了吧。
我写这么多，你好歹多加点分吧…… 参考技术A #include <iostream>
#include <string.h>
using namespace std;
class Worker

public:
 char name[50];
 char address[200];
 int salary;
 Worker(char* name, char* address)
  memset(this->name, 0, 50);
  memcpy(this->name,name,strlen(name));
  memset(this->address, 0, 200);
  memcpy(this->address, address, strlen(address));
 
 virtual ~Worker()
 void printInfo()
 
  cout<<"name:"<<name<<",address:"<<address<<",salary:"<<salary<<endl;
 
;
class AWorker : public Worker

public:
 AWorker(char* name,char* address, int salary):Worker(name,address)this->salary = salary;
;
class BWorker : public Worker

public:
 BWorker(char* name,char* address,int total_numbers, int every):Worker(name,address)this->salary = total_numbers*every;
;
class CWorker : public Worker

public:
 CWorker(char* name,char* address,int total_hours, int every):Worker(name,address)this->salary = total_hours*every;
;
int main()

 Worker* w = NULL;
 w=new AWorker((char*)"A Worker", (char*)"A address", 2000);
 w->printInfo();
 w=new BWorker((char*)"B Worker", (char*)"B address", 100,15);
 w->printInfo();
 w=new CWorker((char*)"C Worker", (char*)"C address", 80, 30);
 w->printInfo();
 return 0;

本回答被提问者采纳 参考技术B 让我写我也写不出来，呵呵，我想说是我在学编程还是你在学编程，写一个工人类，里面有个虚函数工资，三类工人通过继承这个类，来重写这个工资函数，其他乱起八糟的一起写进去。 参考技术C 留下邮箱！

希望能帮到你，哪里不清楚再问。 参考技术D class Worker

public:
Worker(string name, string addr);
string name();
string addr();
virtual int salary();
;
class WorkerWithFixedSalary : public Worker

void setSalary();
virtual int salary() return _salary;
int _salary;

...

面向对象编程语言特征：封装继承多态

面向对象是在编程中很重要的一种编程思想，掌握了这种思想可以在很大程度上提高我们的开发效率，下面来说一下面向对象的三大特征和使用方法。

面向对象编程语言： C++、Python、Java、Swilt、C#

封装：隐藏对象的实现细节，让使用者不关心这些细节
封装中包含两种特殊的封装方法，私有属性和私有方法，这两种方法有同一种特性，
那就是私有属性或方法只能通过类中的方法调用，不可以在类的外部调用定义的私有属性否则会执行报错

#示例
class home:
def __init__(self,m):
self.__m = m

def __one(self):
prit(‘这是私有方法‘)

def tow(self):
print(self.__m)
self.__one()

h=home(‘这是私有属性‘)
h.two()

单继承：在不改变原来类的基础上既可以用原来的类又可以添加新的方法,可以用作于功能的扩展，编程中建议使用单继承 ，

不建议使用多继承，多继承在编程中有一些缺陷，在程序执行 过程中容易出现标识符（名字空间）冲突问题，所以谨慎使用多继承。

#示例
class A:
def Aname(self):
print(‘Jimmy‘)
class B(A):
def Bname(self):
print(‘Jack‘)

p = B()
p.Aname()#用B对象调用A类中的name方法 Jimmy
p.Bname()#调用B类中的name方法 Jack

 

多态：多种状态，是指由有继承、派生关系类中，调用基类的方法，实际能够调用子类的覆盖方法的现象叫做多态。
多态的调用方法与对象有关，不予类有关（python中只有动态）动态调用多个同类的对象规划为一类来统一处理，
再说的通俗一点，就是不同的对象调用相同的方法执行不同的行为就叫做多态。

#示例
class A:
def run(self):
print(‘A类的run方法‘)

class B(A):
def run(self):
print(‘B类的run方法‘)

class C(B):
def run(self):
print(‘C类的run方法‘)

def my_run(s):
s.run()

s1 = A()
s2 = B()
my_run(s1)
my_run(s2)