C++回顾（十）—— 多态

10.1 问题引出

10.1.1 如果子类定义了与父类中原型相同的函数会发生什么？

• 函数重写
  在子类中定义与父类中原型相同的函数，函数重写只发生在父类与子类之间

• 重载与重写区别：
  （1）重载：同一个作用域；
  子类无法重载父类函数，父类同名函数将被覆盖；
  重载是在编译期间根据参数类型和个数决定；

  （2）重写：发生于父类、子类之间；
  父类和子类函数有相同的函数原型；
  使用virtual关键字声明后能够产生多态；
  运行期间根据具体对象类型决定调用的函数。

示例代码：

#include <iostream>

using namespace std;

class Parent
{
public:
	void show()
	{
		cout << "this is parent"  << endl;
	}
};

class Child : public Parent
{
public:
	void show()
	{
		cout << "this is Child" << endl;
	}
};

int main()
{
	Parent *p1 = new Child;   //基类指针指向派生类对象
	p1->show();   //静态联编：编译器根据p1的类型（Parent *）调用Parent里面的show函数

	return 0;
}

运行结果：

问题在于：这里应该是要调用子类的show函数，怎么解决呢？

10.1.2 面向对象新需求

• 根据实际的对象类型来判断重写函数的调用
  如果父类指针指向的是父类对象则调用父类中定义的函数
  如果父类指针指向的是子类对象则调用子类中定义的重写函数
  

10.1.3 解决方案

• C++中通过virtual关键字对多态进行支持
• 使用virtual声明的函数被重写后即可展现多态特性

10.2 多态成立的三个条件

10.2.1 多态的的概念

直观点说，多态就是指相同的语句有不同的执行结果（多态：多种形态）

10.2.2 三个条件

（1）要有继承

（2）要有虚函数的重写

（3）用父类指针(父类引用)指向子类对象

示例代码：

#include <iostream>

using namespace std;

class Parent
{
public:
	virtual void show()    //被virtual修饰的函数叫虚函数
	{
		cout << "this is parent"  << endl;
	}
};

class Child : public Parent   //1、要有继承
{
public:
	void show()    //2、要有虚函数重写（发生在不同的作用域中，函数原型相同）
	{
		cout << "this is Child" << endl;
	}
};

int main()
{
	Child c;
	Parent p;

	p = c;

	Parent *p1 = new Child;   //3、基类指针指向派生类对象
	p1->show();   //动态联编：运行的时候才能知道p1指向什么对象
	delete p1;
	p1 = new Parent;    //基类指针指向基类对象
	p1->show();     //相同的语句有不同的执行结果（多态：多种形态）
	delete p1;

	return 0;
}

运行结果：

10.3 静态联编和动态联编

• 1、联编是指一个程序模块、代码之间互相关联的过程。
• 2、静态联编（static binding），是程序的匹配、连接在编译阶段实现，也称为早期匹配。（重载函数使用静态联编）。
• 3、动态联编是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。（switch 语句和 if 语句是动态联编的例子）。

---

补充：

• 1、C++与C相同，是静态编译型语言
• 2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。
• 3、由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象
• 从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编。

10.4 多态原理实现

• 说明1：通过虚函数表指针调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。

• 说明2：出于效率考虑，没有必要将所有成员函数都声明为虚函数
  
  示例代码：

#include <iostream>

using namespace std;

class Parent
{
public:
	int a;
	virtual void show()
	{
		cout << "thsi is parent" << endl;
	}
};

class Child : public Parent
{
public:
	virtual void show()
	{
		cout << "this is Child" << endl;
	}
};

int main()
{
    Parent pp; 
    Child cc; 

    cout << sizeof(cc) << endl;
    cout << sizeof(pp) << endl;
    cout << "Parent对象的起始地址 " << &pp << endl;
    cout << "成员变量a的起始地址 "  << &pp.a << endl;

	Parent *p = new Child;
	p->show();   //通过指针找到对象，通过对象前8个字节找到虚函数表，通过虚函数表找到对应的函数，调用函数（效率低）
		    //不要将所有函数都声明成虚函数

	delete p;
	p = new Parent;
	p->show();


	return 0;
}

运行结果：

10.5 虚析构函数

10.5.1 通过父类指针释放所有的子类资源

• 在什么情况下应当声明虚函数
  构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数
  析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象

• 虚析构函数：通过父类指针释放子类对象
  
  
  不用虚析构函数的话，这里释放对象的时候，就不会调用子类的析构函数

示例代码：

#include <iostream>

using namespace std;

class Parent
{
public:
	Parent()
	{
		cout << "Parent构造函数" << endl;
	}
	virtual void show()    //被virtual修饰的函数叫虚函数
	{
		cout << "this is parent"  << endl;
	}

	virtual ~Parent()
	{
		cout << "Parent析构函数" << endl;
	}
};

class Child : public Parent   //1、要有继承
{
public:
	Child()
	{
		cout << "Child构造函数" << endl;
	}
	void show()    //2、要有虚函数重写（发生在不同的作用域中，函数原型相同）
	{
		cout << "this is Child" << endl;
	}
	~Child()
	{
		cout << "Child析构函数" << endl;
	}
};

int main()
{
	Parent *p1 = new Child;  
	p1->show();  
	delete p1;    //释放派生类对象  虚析构函数：通过基类指针释放派生类对象

	return 0;
}

运行结果：