C++学习笔记 第48课 同名覆盖问题

编程实验

子类对象的兼容性，48-1.cpp

#include <iostream>
using namespace std;

class Parent
{
public:
    int mi = 0;

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

    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mv = 0;

    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;

}

结论：当使用父类指针(引用)指向子类对象时

• 子类对象退化为父类对象
• 只能访问父类中定义的成员
• 可以直接访问被子类覆盖的同名成员

特殊的同名函数

思考：当函数重写遇上赋值兼容会发生什么？

编程实验 48-2.cpp

#include <iostream>
using namespace std;

class Parent
{
public:
    int mi = 0;

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

    void add(int a, int b)
    {
        mi += (a + b);
    }

    void print()
    {
        cout << "Parent" << endl;
    }
};



class Child : public Parent
{
public:
    int mv = 0;

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

    void print()
    {
        cout << "Child" << endl;
    }
};

void how_to_print(Parent* p)
{
    p->print();
}

int main()
{
    Parent p;
    Child c;

    how_to_print(&p);
    how_to_print(&c);

    return 0;

}

结果：

问题分析：

• 编译期间，编译器只能根据指针的类型判断所指向的对象
• 根据赋值兼容，编译器会认为父类对象指针所指向的是父类对象
• 因此，编译结果只能是调用父类中定义的同名函数
  -

小结

• 子类对象可以当作父类对象使用(赋值兼容)
• 父类指针可以正确指向子类对象
• 父类引用可以正确的代表子类对象
• 子类可以重写父类中的成员函数