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

1、 父子间的赋值兼容（子类对象可以当作父类对象使用）

    1.1、 子类对象可以 直接赋值 给父类对象

    1.2、 子类对象可以 直接初始化 父类对象

    1.3、 父类指针 可以 直接指向子类对象（应该只能使用里面相同的成员吧？）

    1.4、 父类引用 可以 直接引用子类对象

/*********************    子类对象的兼容性      ********/

#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命名的函数（只要有一个与父类同名的函数），所以父类的所有名为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); //同上

    

    cout << pp->mi << endl;//  父类的mi 125；

    

    //为什么编译不过

    //pp->mv = 1000;    //用父类指针，只能调用父类的成员变量

    //pp->add(1, 10, 100);        //父类指针，只能调用父类的成员函数

    

    //原因分析：

    //编译期间，编译器只能根据指针的类型判断所指向的对象。根据赋值兼容性，编译器认为父类指针（按照指针的类型）指向的是父类对象

    //因此，编译结果只可能是调用父类中定义的同名函数。//子类对象退化为父类对象。

    

    return 0;

}

2、 父类指针（引用）：当使用父类指针（引用）指向子类对象时

    2.1、 子类对象 退化为 父类对象

    2.2、只能访问父类中定义的成员    

    2.3、 可以 直接访问 被子类 覆盖的同名成员

3、 特殊的同名函数

    3.1、 子类中可以重定义父类中己经存在的成员函数，这种重定义发生在继承中，称为 “函数重写” 。

    3.2、 函数重写是同名覆盖的一种特殊情况。

    

/********************  赋值兼容问题 ****************/

#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 am 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函数（传&c时，子类指针退化为父类指针）

*/

void how_to_print(Parent* p)        //全局函数

{

    p->print();

}

int main()

{

    Parent p;

    Child c;

    

    how_to_print(&p);   //期望是parent  实际是parent     

    how_to_print(&c);   //期望是child   实际是parent//必须子类继承父类才会有这种效果。子类指针退化为父类指针

    return 0;

}

4、小结

    4.1、 子类对象可以当作父类对象使用（ 赋值兼容 ）

    4.2、 父类指针可以正确的指向子类对象（因为退化的原因，实际调用父类的成员或函数。）

    4.3、 父类引用可以正确的代表子类对象

    4.4、 子类中可以重写父类中的成员函数