C++深度解析(39)—多态的概念和意义

1.函数重写回顾

• 父类中被重写的函数依然会继承给子类
• 子类中重写的函数将覆盖父类中的函数
• 通过作用域分辨符(::)可以访问到父类中的函数

Child  c;
Parent*  p  =  &c;
c.Parent::print();   // 从父类中继承
c.print()            // 在子类中重写，如果不能使用多态，那么重写无意义。
p->print();          // 父类中定义

2.多态的概念

• 面向对象中期望的行为
• 根据实际的对象类型判断如何调用重写函数
• 父类指针（引用）
  • 指向父类对象时，则调用父类中定义的函数
  • 指向子类对象时，则调用子类中定义的重写函数（前提是父类的函数被virtual修饰）
• 面向对象中的多态的概念
  • 根据实际的对象类型决定函数调用的具体目标
  • 同样的调用语句在实际运行时有多种不同的表现形态

• C++语言直接支持多态的概念
  • 通过使用virtual关键字对多态进行支持 
  • 被virtual声明的函数被重写后具有多态特性 
  • 被virtual声明的函数叫做虚函数 
• 编程实验——多态

#include<iostream>

using namespace std;

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

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

void how_to_print(Parent *p)
{
	p->print();     // 展现多态的行为 
}


int main() 
{
	Parent p;
	Child c;
	
	how_to_print(&p);
	how_to_print(&c);
	
	system("pause");
	
	return 0;
}

3.多态的意义

• 在程序运行过程中展现出动态的特性
• 函数重写（子类重写父类函数）必须多态实现，否则没有意义
• 多态是面向对象组件化程序设计的基础特性

4.理论中的概念

• 静态联编：在程序的编译期间就能确定具体的函数调用（如函数重载）
• 动态联编：在程序实际运行后才能确定具体的函数调用（如函数重写）

5.实例分析

• 动态联编与静态联编    

#include <iostream>
using namespace std;

class Parent 
{
public:
	virtual void func() 
	{
		cout << "void func()" << endl;
	}
	
	virtual void func(int i) 
	{
		cout << "void func(int i) : " << i << endl;
	}
	
	virtual void func(int i, int j) 
	{
		cout << "void func(int i, int j) : " << "(" << i << ", " << j << ")" << endl;
	}
};

class Child : public Parent 
{
public:
	void func(int i, int j)
	{
		cout << "void func(int i, int j) : " << i + j << endl;
	}
	
	void func(int i, int j, int k) 
	{
		cout << "void func(int i, int j, int k) : " << i + j + k << endl;
	}
};

void run(Parent *p)
{
	p->func(1, 2); // 展现多态的特性
				   // 动态联编
}


int main()
{
	Parent p;

	p.func();     // 静态联编
	p.func(1);    // 静态联编
	p.func(1, 2); // 静态联编

	cout << endl;

	Child c;

	c.func(1, 2); // 静态联编

	cout << endl;

	run(&p);
	run(&c);

	cout << endl;

	Parent *p2 = &c;
	p2->func();     //动态联编，virtual函数，尽管func（）在Child中没有重写
	p2->func(5, 6);         //动态联编，

	system("pause");
	
	return 0;
}

• 运行结果

• 使用父类指针（引用）时，函数前加virtual为动态联编，没加virtual为静态联编。
• 使用父类或子类自身声明对象，加不加virtual都是静态联编的。

6.小结

• 函数重写只可能发生在父类与子类之间
• 根据实际对象的类型确定调用的具体函数
• virtual关键字时C++中支持多态的唯一方式
• 被重写的虚函数可表现出多态的特性