7、同名覆盖引发的问题

此文编写参考狄泰软件学院唐佐林老师的视频课程，如有错误之处，欢迎指正。

一、父子间的赋值兼容

第一类赋值兼容

1. 子类对象可以直接赋值给父类对象
2. 子类对象可以直接初始化父类对象

第二类赋值兼容

3. 父类指针可以直接指向子类对象
4. 父类引用可以直接引用子类对象

例程如下：

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

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

class Child:public Parent
{
public:
	int mv;
	void add(int a,int b,int c)
	{
		mv+=(a+b+c);
	}
};
int main()
{
	Parent p1;
	Child c1;
	//第一类赋值兼容，也就是把子类当成父类使用
	p1=c1;
	Parent p2(c1);
	
	//第二类赋值兼容
	Parent& rc=c1;
	Parent* pc=&c1;
	
	rc.mi=100;
	rc.add(10);//没有发生同名覆盖问题？
	rc.add(10,20);//没有发生同名覆盖问题？
	cout<<"rc.mi="<<rc.mi<<endl;
	
	//pc->mv=1000;//错误原因看运行结果1
	//pc->add(1,2,3);//错误原因看运行结果1
	
	pc->mi=1000;
	pc->add(1);
	cout<<"pc->mi="<<pc->mi<<endl;

	return 0;
}

运行结果1：

注释掉错误语句，修改代码后的运行结果2：

分析：当使用父类指针或者引用指向子类对象时：

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

二、当函数重写遇上赋值兼容

首先我们先了解什么叫函数重写，
1、在子类中重定义父类中已经存在的成员函数，
2、这种重定义发生在继承中
3、函数重写是同名覆盖的一种特殊情况
它是一种下面通过一个例程来了解：

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

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

class Child:public Parent
{
public:
	void print()
	{
		cout<<"I am a Child."<<endl;
	}
};
int main()
{
	Child c1;
	c1.print();

	return 0;
}

分析：因为父类中的print函数和子类中的print函数是一样的，所以这就叫做函数重写，有时候，函数重写是必要的，因为像如果不用函数重写，那么运行结果就不一定如期望那样了，我们修改下这个程序，也就是把子类中的print函数给删除了，看看会发生什么：

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

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

class Child:public Parent
{
public:
	
};
int main()
{
	Child c1;
	c1.print();
	return 0;
}

分析：当没有在子类中进行函数重写的时候，这时候就继承了父类的代码，调用了父类的print函数了，显然不是我们所期待的结果。

下面我们再通过一个程序加深对同名覆盖引发的问题的理解：

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

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

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

void how_to_print(Parent* p)
{
	p->print();
}
int main()
{
	Parent p1;
	Child c1;
	how_to_print(&p1);
	how_to_print(&c1);
	return 0;
}

分析：

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

三、总结

1. 子类对象可以当成父类对象使用
2. 父类指针可以正确的指向子类对象
3. 父类引用可以正确的代表子类对象
4. 子类中可以重写父类中的成员函数