48、赋值兼容性原则以及同名覆盖引发的问题

1、父子间的赋值兼容

• 子类对象可以当做父类对象使用（兼容性）
  — 子类对象可以直接赋值给父类对象
  — 子类对象可以直接初始化父类对象
  — 父类指针可以直接指向子类对象
  — 父类引用可以直接引用子类对象

• 当使用父类指针（引用）指向子类对象时
  — 子类对象退化为父类对象
  — 只能访问父类中定义的成员
  — 可以直接访问被子类覆盖的同名成员

#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
	int mi;
	Parent()
	{

	}
	void add(int v)
	{
		mi += v;
	}
	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(1);
	rp.add(2, 3);

	/*为什么编译不过？*/
	//pp->mv = 1000;
	//pp->add(1, 2, 3);
	return 0;
}

按照上面讲的赋值兼容性的一些原则，第46行和第47行程序报错。子类对象可以给父类对象赋值和初始化。父类指针或引用可以指向子类对象，但是此时这个子类对象会退化为父类对象，所以这个指针或者引用能调用的只能是父类里面的成员变量和成员函数。

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)
	{
		mi += a + b;
	}
	void print()
	{
		cout << "I'm 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'm Child." << endl;
	}
};
void how_to_print(Parent* p)
{
	p->print();
}
int main()
{
	Parent p;
	Child c;
	p.print();
	c.print();

	how_to_print(&p);
	how_to_print(&c);
	return 0;
}

其实我个人觉得，学过了前面一部分，对得到这个结果并不感到意外。全局函数how_to_print里面的参数是Parent 类型的指针，可以指向父类对象，这是没问题的；如果指向子类对象，那么这个子类对象会退化为父类对象。所以最后的输出结果都是调用父类的print（）函数。
得到的结果不是我们期望的，我们希望第一行打印Child，第二行打印Parent，但是实际打印了两个Parent。原因在于编译器为了安全起见，觉得第35行不管你是父类对象还是子类对象，都调用父类的版本是最安全的。但却不是我们期望的。

小结：

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