分配给派生类和多态性的基类指针

Question

对于下面的代码，当基类指针被分配给派生类时，我有关于多态性的问题。

当派生类的对象直接使用print函数时，输出是显而易见的。

当我使用基类指针并指向派生类的对象时，会使用基类的print函数，但输出的是派生对象的信息。有人能详细解释一下吗？谢谢！

class Person {
public:
    Person() {};
    Person(string nm):name(nm) {};
    void print() const;
private:
   string name;
};

class Student : public Person {
public:
    Student(int num, string nm) : IDNumber(num), Person(nm) {};
    void print() const;
private:
    int IDNumber;
}

class Employee : public Person {
public:
    Employee(int num, int sal, string nm) : IDNumber(num), salary(sal), Person(nm) {};
    void print() const;
private:
    int IDNumber, salary;
}

void Person::print() const {
    cout << name << endl;
}

void Student::print() const {
    cout << "GoGoGo! ";
    Person::print();
}

void Employee::print() const {
    cout << "I work: ";
    Person::print();
}

int main() {
    Person per("Peter");
    Student stu(3141, "Sally");
    Employee emp(2718, 40, "Edward");

    Person* ptr = &per;
    Person* ptr2 = &stu;
    Person* ptr3 = &emp;

    per.print();   //Peter
    stu.print();   //GoGoGo! Sally
    emp.print();   //I work: Edward

    ptr->print();  //Peter
    ptr2->print(); //Sally
    ptr3->print(); //Edward
    return 0;
}

Answer 1

代码行为的关键词是“静态绑定和动态绑定”。

当编译器在编译时读取下面的语句时，它看到ptr3是person类型的，它检查Person类并用Person类中定义的print函数地址替换print()。所有这些都发生在编译时，这就是为什么叫做静态绑定。

ptr3->print();

为什么它能够打印通过派生类对象输入的信息？

在下面的语句中，您调用基类的构造函数并在基类成员中输入信息。ptr3*属于基类类型，因此它可以访问其成员。

Employee(int num, int sal, string nm) : IDNumber(num), salary(sal), Person(nm) {};

如果，你赚了int工资;员工类中的公共成员，并尝试通过以下方式访问

ptr3-

它会给出错误

ptr3没有指定薪金的成员

因为salary是派生类的成员，基类对象无法访问它。

Answer 2

函数< code>print()不是< code >虚拟的，因此不是多态的。基类上的函数隐藏了子类的函数。

要使代码按预期工作，您唯一要做的就是在类< code>Person中使< code>print()成为虚拟的:

class Person {
public:
    Person() {};
    virtual ~Person() {};
    Person(string nm):name(nm) {};
    virtual void print() const;
private:
   string name;
};

请注意，我添加了一个虚拟析构函数，这是每个要继承的类所必需的。

输出显示了派生对象的信息，因为子类继承了基类的成员(即< code>name，它被设置为Peter、Sally和Edward)。