1. 函数重写回顾
（1）父类中被重写的函数依然会继承给子类
（2）子类中重写的函数将覆盖父类中的函数
（3）通过作用域分辨符(::)可以访问到父类中的函数
Child c; Parent* p = &c; c.Parent::print(); //从父类中继承 c.print(); //在子类中重写 p->print(); //父类中定义
2. 面向对象中期望的行为
（1）根据实际的对象类型判断如何调用重写函数
（2）父类指针（引用）
①指向父类对象时，则调用父类中定义的函数
②指向子类对象时，则调用子类中定义的重写函数。
3. 面向对象中多态的概念
（1）根据实际的对象类型决定函数调用的具体目标
（2）同样的调用语句在实际运行时有多种不同的表现形态
（3）C++语言直接支持多态的概念
①通过使用virtual关键字对多态进行支持
②被virtual声明的函数被重写后具有多态特性
③被virtual声明的函数叫做虚函数
【编程实验】多态初体验（可对比第48课的非多态版本）
#include <iostream> #include <string> using namespace std; class Parent { public: virtual void print() //多态版本，与48课唯一的不同！ { cout << "I'm Parent." << endl; } }; class Child : public Parent { public: void print() //虚函数，父类己加virtual，这里不必再写 { cout << "I'm Child." << endl; } }; void how_to_print(Parent* p) { p->print() ; //展现多态的行为 } int main() { Parent p; Child c; //多态，根据实际对象类型来调用虚函数 how_to_print(&p); //I'm Parent. how_to_print(&c); //I'm Child. return 0; }
4. 多态的意义
（1）在程序运行过程中展现出动态的特性
（2）函数重写必须多态实现，否则没有意义
（3）多态是面向对象组件化程序设计的基础特性
5. 理论中的概念
（1）静态联编：在程序的编译期间就能确定具体的函数调用（如函数重载）
（2）动态联编：在程序实际运行后才能确定具体的函数调用（如函数重写）
（3）小结：
①使用父类指针（引用）时，函数前加virtual为动态联编，没加virtual为静态联编。
②使用父类或子类自身声明对象，加不加virtual都是静态联编的。
【实例分析】动态联编与静态联编
#include <iostream> #include <string> using namespace std; class Parent { public: virtual void func() { cout << "Parent: void func()" << endl; } virtual void func(int i) { cout << "Parent: void func(int i): " << i << endl; } virtual void func(int i, int j) { cout << "Parent: void func(int i, int j): " << i << ", " << j << endl; } }; class Child : public Parent { public: void func(int i, int j) { cout << "Child: void func(int i, int j): " << i << ", " << j << endl; } void func(int i, int j, int k) { cout << "Child: 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); //静态联编 run(&p); run(&c); cout << endl; Parent* p2 = &c; p2->func(); //动态联编,virtual函数，尽管func()在Child中没有被重写 return 0; }
【编程实验】江湖恩怨
//场景：庄主打老怪 #include <iostream> #include <string> using namespace std; //老怪 class Boss { public: //无名怪招 int fight() { int ret = 10; //威力10 cout <<"Boss::fight(): " << ret << endl; return ret; } }; //老庄主 class Master { public: //八剑齐飞 virtual int eightSwordKill() { int ret = 8; //威力10 cout <<"Master::eightSwordKill(): " << ret << endl; return ret; } }; //少庄主 class NewMaster : public Master { public: //八剑齐飞 int eightSwordKill() { //少庄主对老庄主的八剑齐飞进行改造，练就了双臂的八剑齐飞 //威力大增 int ret = Master::eightSwordKill() * 2; //威力是老庄主的2倍 cout <<"NewMaster::eightSwordKill(): " << ret << endl; return ret; } }; //战场pk void field_pk(Master* master, Boss* boss) { int k = master->eightSwordKill(); int b = boss ->fight(); if(k < b) { cout <<"Master is killed..." << endl; } else { cout <<"Boss is killed..." << endl; } } int main() { Master master; Boss boss; cout <<"Master vs Boss" << endl; field_pk(&master,&boss); cout << endl; cout <<"NewMaster vs Boss" << endl; NewMaster newMaster; field_pk(&newMaster, &boss); return 0; }
/*输出结果
Master vs Boss
Master::eightSwordKill(): 8
Boss::fight(): 10
Master is killed...
NewMaster vs Boss
Master::eightSwordKill(): 8
NewMaster::eightSwordKill(): 16
Boss::fight(): 10
Boss is killed...
*/
6. 小结
（1）函数重写只可能发生在父类与子类之间
（2）根据实际对象的类型确定调用的具体函数
（3）virtual关键字是C++中支持多态的唯一方式
（4）被重写的虚函数可表现出多态的特性