C++深度解析(38)—同名覆盖引发的问题

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

• 子类对象可以直接赋值给父类对象
• 子类对象可以直接初始化父类对象
• 父类指针可以直接指向子类对象
• 父类引用可以直接引用子类对象

#include<iostream>

using namespace std;

class Parent 
{
public:
	int mi;
	
	void add(int i) 
	{
		mi += i;
	}
	
	void add(int a, int b) 
	{
		mi += (a + b);
	}
};

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);  // 父类指针，只能调用父类的成员函数
	
	// 原因分析：
	// 编译期间，编译器只能根据指针的类型判断所指向的对象。
	// 根据赋值兼容性，编译器认为父类指针（按照指针的类型）指向的是父类对象
	// 因此，编译结果只可能是调用父类中定义的同名函数。//子类对象退化为父类对象。

	system("pause");
	
	return 0;
}

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

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

3.特殊的同名函数

• 子类中可以重定义父类中己经存在的成员函数，这种重定义发生在继承中，称为“函数重写”。
• 函数重写是同名覆盖的一种特殊情况。

class Parent
{
public:
        void print()
        {
            cout << "I am Parent" <<endl;
        }
}

//函数重写
class Child : public Parent
{
public:
        void print()
        {
            cout << "I am child" <<endl;
        }
}

4.编程实验——赋值兼容的问题

#include<iostream>

using namespace std;

class Parent 
{
public:
	int mi;
	
	void add(int i) 
	{
		mi += i;
	}
	
	void add(int a, int b) 
	{
		mi += (a + b);
	}
	
	void print()
	{
		cout << "I am Parent" << endl;
	}
};

class Child : public Parent 
{
public:
	int mv;
	
	void add(int x, int y, int z) 
	{
		mv += (x + y + z);
	}
	
	void print() 
	{
		cout << "I am 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

	system("pause");
	
	return 0;
}

• 运行结果：
• 问题分析 
  • 编译期间，编译器只能根据指针的类型判断所指向的对象 
  • 根据赋值兼容，编译器认为父类指针指向的是父类对象 
  • 编译结果只可能是调用父类中定义的同名函数
• 在编译这个函数的时候，编译器不可能知道指针p究竟指向了什么。但是编译器没有理由报错。于是，编译器认为最安全的做法是调用 父类的print函数，因为父类和子类肯定都有相同的print函数。编译器的这种处理显然不是我们所期望的，于是引入了多态的概念

5.小结

• 子类对象可以当作父类对象使用（赋值兼容）
• 父类指针可以正确的指向子类对象（因为退化的原因，实际调用父类的成员或函数）
• 父类引用可以正确的代表子类对象
•  子类中可以重写父类中的成员函数