目录
- 1. 多态的概念和意义
- 2. C++多态的实现原理
- 3. 构造析构与虚函数
- 4. C++对象模型分析
- 5. 用C实现面向对象,展现继承与多态本质
1. 多态的概念和意义
回忆一下上一节继承(二)函数重写示例代码中的how_to_print(),当时我们所期望的结果是
- 根据实际的对象类型判断如何调用重写函数
- 父类指针(引用)指向
- 父类对象则调用父类中定义的函数
- 子类对象则调用子类中定义的重写函数
要实现上述期望结果,需要用到多态的知识。
多态是面向对象理论中的概念,其含义为
- 根据实际的对象类型决定函数调用的具体目标
- 同样的调用语句在实际运行时有多种不同的表现形态
C++语言直接支持多态的概念
- 通过使用virtual关键字对多态进行支持
- 被virtual声明的函数叫做虚函数
- 虚函数被重写后可表现出多态的特性
静态联编 VS 动态联编
- 静态联编:在程序编译期间就能确定具体的函数调用,如函数重载
- 动态联编:在程序运行期间才能确定具体的函数调用,如重写虚函数
#include <iostream>
#include <string>
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;
p.print(); // 静态联编
c.print(); // 静态联编
how_to_print(&p); // 动态联编,Expected: I'm Parent
how_to_print(&c); // 动态联编,Expected: I'm Child
return 0;
}
多态的意义
- 在程序运行过程中展现出动态的特性
- 函数重写只可能发生在父类与子类之间,且必须多态实现,否则没有意义
- 多态是面向对象组件化程序设计的基础特性
示例代码:江湖恩怨
#include <iostream>
#include <string>
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;
}
cout << endl;
}
int main()
{
Boss boss;
Master master;
NewMaster newMaster;
cout << "Master vs Boss" << endl;
field_pk(&master, &boss);
cout << "NewMaster vs Boss" << endl;
field_pk(&newMaster, &boss);
return 0;
}
2. C++多态的实现原理
- 当类中声明虚函数时,编译器会在类中生成一个虚函数表
- 虚函数表是一个存储成员函数地址的数据结构,该数据结构由编译器自动生成与维护
- 虚函数会被编译器放入虚函数表中
- 存在虚函数时,每个类对象中都有一个指向虚函数表的指针
- 虚函数表指针位于类对象的起始位置,再往后才是成员变量
3. 构造析构与虚函数
- 构造函数不可能成为虚函数,构造函数中不可能发生多态行为
- 在构造函数执行结束后,虚函数表指针才会被正确的初始化
- 析构函数可以成为虚函数,析构函数中不可能发生多态行为
- 在析构函数执行时,虚函数表指针已经被销毁
- 建议在设计类时将析构函数声明为虚函数
/*
* 1、构造函数不可能成为虚函数,析构函数可以并且建议设计为虚函数
* 2、构造函数和析构函数中调用虚函数不能发生多态行为,只会调用当前类中定义的函数版本
*/
#include <iostream>
#include <string>
using namespace std;
class Base
{
public:
Base()
{
cout << "Base()" << endl;
func();
}
virtual void func()
{
cout << "Base::func()" << endl;
}
virtual ~Base()
{
func();
cout << "~Base()" << endl;
}
};
class Derived : public Base
{
public:
Derived()
{
cout << "Derived()" << endl;
func();
}
virtual void func()
{
cout << "Derived::func()" << endl;
}
~Deri