第48课 同名覆盖引发的问题

#include <iostream>
#include <string>
using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }  
   
    void add(int a, int b)  //Parent中的两个add构成重载关系
    {
        mi += (a + b);
    }    
};

/*
  因child出现了以add命名的函数（只要有1个与父类同名的函数），所以父类的所有名为add的函数
   在子类中都会被隐藏起来
*/
class Child : public Parent
{
public:
    int mv;
    
    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;
}

#include <iostream>
#include <string>
using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }  
   
    void add(int a, int b)  //Parent中的两个add构成重载关系
    {
        mi += (a + b);
    }   

    void print()
    {
        cout << "I‘m Parent." << endl;
    }    
};

/*
  因child出现了以add命名的函数（只要有1个与父类同名的函数），所以父类的所有名为add的函数
   在子类中都会被隐藏起来
*/
class Child : public Parent
{
public:
    int mv;
    
    void add(int x, int y, int z)
    {
        mv += (x  + y + z);
    }
    
    void print()
    {
        cout << "I‘m Child." << endl;
    }   
};

/*
编译以下函数时，编译器不可能知道指针p究竟指向了什么
但是编译器没有理由报错。于是，它认为最安全的做法是调用
父类的print函数，因为父类和子类肯定都有相同的print函数。
*/
void how_to_print(Parent* p)
{
    p->print();
}

int main()
{
    Parent p;
    Child c;
    
    how_to_print(&p); //期望：I‘m Parent 实际：I‘m Parent.
    how_to_print(&c); //期望：I‘m Child，实际：I‘m Parent.

    return 0;
}