类的继承——父子同名覆盖问题及多态的概念

本文参照于狄泰软件学院，唐佐林老师的——《C++深度剖析教程》

父子间的赋值兼容

通过我们的验证，子类可以存在父类中的同名变量和同名函数。似乎使用上也没有什么大的问题。
那么真的就没有问题了吗？

示例代码：父子间的赋值兼容

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;

    void add(int i)
    {
        mi += i;
    }

    void add(int a, int b)
    {
        cout << "class Parent" << endl; 
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mv;

    void add(int a, int b)
    {
        cout << "class Child" << endl; 
        mv += (a + b);
    }

    void add(int x, int y, int z)
    {
        mv += (x + y + z);
    }
};

int main()
{
    Parent p;
    Child c;

    p = c;

    Parent p1(c);

    Parent& rp = c;
    Parent* pp = &c;

    rp.mi = 100;
    rp.add(5);             // 没有发生同名覆盖?
    rp.add(10, 10);        // 没有发生同名覆盖?

    /* 为什么编译不过? */
    //pp->mv = 1000;
    //pp->add(1, 10, 100);

    return 0;
}

问题：
1. 编译时，我们发现pp->mv = 1000; pp->add(1, 10, 100);这两条语句报错了。为什么会报错呢？
2. 然而rp.add(10, 10);这个输出的却是‘class parent’父类的同名函数。我们使用父类对象引用了子类对象而已，为什么会调用了父类的函数呢？

我们发现用父类的指针指向子类时，子类的成员函数无法访问了。根据这个现象，我们可以
猜测：当使用父类指针（引用）指向子类对象时：

1. 子类对象退化为父类对象
因为子类可以定义父类中已经存在的成员函数，这种重定义发生在继承中，叫做函数重写。那么当函数重写遇上同名覆盖会发生什么呢？编译器会如何判断父类和子类的同名函数呢？

2. 编译期间，编译器只能根据指针的类型判断所指向的对象
根据赋值兼容，编译器认为父类指针指向的是父类对象
因此，编译的结果是只能调用父类中定义的同名函数。
可以直接访问被子类覆盖的同名成员。

编译器的处理方法是合理的。但却不是我们所期望的结果。那我们有别的方法解决这个问题吗？

多态解决继承中赋值兼容问题

关于父类指针指向的问题，这个现象是由编译器所决定的，但是面向对象中期望的行为却是：
1. 根据实际的对象类型判断如何调用同名的函数
2. 当父类指针（引用）指向父类对象时，调用父类中定义的函数
3. 当父类指针（引用）指向子类对象时，调用子类中定义的函数

这实际就是面向对象中多态的概念：多态指的是根据实际的对象类型决定函数调用的具体目标，同样的调用语句在实际运行时有多种不同的表现形态。

问题：那么，C++是如何支持多态的概念的呢？
1. C++通过使用virtual关键字对多态进行支持
2. 被virtual声明的函数被重写后具有多态的特性
3. 被virtual声明的函数叫做虚函数

示例代码：多态的初体验

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    virtual void print()
    {
        cout << "I'm Parent." << endl;
    }
};

class Child : public Parent
{
public:
    void print()
    {
        cout << "I'm Child." << endl;
    }
};

void how_to_print(Parent* p)
{
    p->print();     // 展现多态的行为
}

int main()
{
    Parent p;
    Child c;

    how_to_print(&p);    // Expected to print: I'm Parent.
    how_to_print(&c);    // Expected to print: I'm Child.

    return 0;
}

输出结果：
I’m Parent.
I’m Child.

从输出结果我们可以知道，我们想要的效果达到了。这就是多态的功能，那么我们为什么需要多态呢？多态的意义是什么？
1. 在程序运行过程中展现出动态的特性
2. 函数重写必须多态实现，否则没有意义
3. 多态是面向对象组件化程序设计的基础特性。