---- 整理自狄泰软件唐佐林老师课程

1. 函数重写回顾

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

p->print()不符合预期，期望调用子类中的print，实际调用父类的print

2. 多态的概念和意义

• 面向对象中期望的行为：
  • 根据 实际的对象类型 判断如何调用重写函数
  • 父类指针/引用指向父类对象则调用父类对象中定义的函数
  • 父类指针/引用指向子类对象则调用子类中定义的重写函数

2.1 面向对象中的多态的概念

• 根据 实际的对象类型 决定函数调用的具体目标
• 同样的调用语句在实际运行时有多种不同的表现形式
  

2.2 C++语言直接支持 多态 的概念

通过使用 virtual关键字 对多态进行支持

被virtual声明的函数被重写后具有多态 特性

被virtual声明的函数叫做 虚函数

• 编程实验：多态的初体验

#include 
#include using namespace std;class Parent
{
public:virtual void print(){cout << "I'm Parent." << endl;}
};class Child : public Parent
{
public:void print(){cout << "I'm Child." << endl;}
};void how_to_print(Parent* p)
{p->print();     // 展现多态的行为
}int main()
{Parent p;Child c;how_to_print(&p);    // Expected to print: I'm Parent.how_to_print(&c);    // Expected to print: I'm Child.return 0;
}

2.3 多态的意义

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

2.4 理论中的概念

• 静态联编：

  • 在程序的 编译期间 就能确定 具体的函数调用
    如：函数重载

• 动态联编：

  • 在程序 实际运行后 才能确定 具体的函数调用
    如：函数重写

• 实例分析：动态联编和静态联编

#include 
#include 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);return 0;
}

2.5 编程实验

#include 
#include using namespace std;class Boss
{
public:int fight(){int ret = 10;cout << "Boss::fight() : " << ret << endl;return ret;}
};class Master
{
public:virtual int eightSwordKill(){int ret = 8;cout << "Master::eightSwordKill() : " << ret << endl;return ret;}
};class NewMaster : public Master
{
public:int eightSwordKill(){int ret = Master::eightSwordKill() * 2;cout << "NewMaster::eightSwordKill() : " << ret << endl;return ret;}
};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 << "NewMaster vs Boss" << endl;NewMaster newMaster;field_pk(&newMaster, &boss);return 0;
}

3. 小结

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