什么是多态？
程序运行时，父类指针可以根据具体指向的子类对象，来执行不同的函数
虚函数实现多态
- 每一个有虚函数的类（或者有虚函数的类的派生类）都有一个虚函数表
- 虚函数表占4个字节
- 类对象存储空间的最前端存放的就是虚函数表的指针
- 该类的任何对象中都放着虚函数表的指针，vptr指针
- 虚函数表是编译器生成的，程序运行时被载入内存
- 一个类的虚函数表中列出了该类的全部虚函数地址
举例
#include <iostream>
using namespace std;
class A {
public:
int i;
//父类虚函数必须要有virtual关键字
virtual void func() {
cout << "father" << endl;
}
virtual void func2() {}
};
class B : public A {
int j;
void func() {
cout << "son" << endl;
}
};
int main() {
A* a = nullptr;//父类指针
A father;//父类对象
B son;//子类对象
a = &father;//父类指针指向父类对象
a -> func();//执行父类的func函数
a = &son;//父类指针指向子类对象
a -> func();//执行子类的func函数
return 0;
}
输出结果：
当传入父类对象时，执行父类的成员函数；当传入子类对象时，指向子类成员函数
father
son
多态的函数调用语句被编译成根据基类指针（或基类引用）所指向的对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的一系列指令
- 比如说有一个父类指针a要调用虚函数func()函数
- 取出父类指针所指位置的前4个字节（对象所属类的虚函数表的地址，也就是虚函数表指针），如果父类指针指向的是类A的对象，则这个地址就是类A的虚函数表的地址，如果父类指针指向的是类B的对象，则这个地址就是类B的虚函数表的地址
- 根据虚函数表的地址就找到了虚函数表，在虚函数表中以函数名为索引，查找要调用的虚函数的地址
- 根据找到的虚函数的地址调用虚函数
多态机制能够提高程序的开发效率，但也增加了程序运行时的开销
- 虚函数表，各个类对象中包含的4个字节的虚函数表的地址都是空间上额外的开销
- 查虚函数表的过程是时间上的额外开销
父类的构造函数中调用虚函数会发生多态吗
#include <iostream>
using namespace std;
class Parent {
public:
Parent() {
// 父类的构造方法中执行虚函数，会发生多态吗？
fun();
}
virtual void fun() { cout << "父类" << endl; }
};
class Child : public Parent {
public:
Child() { fun(); }
void fun() { cout << "子类" << endl; }
};
int main() {
Child c;
return 0;
}
输出：
创建子类对象时，会先创建父类对象，父类构造函数中调用虚函数fun()，执行的是父类的fun()函数，并没有发生多态。
父类构造函数中调用虚函数，不会发生多态，跟虚函数表指针分步初始化有关。
父类
子类
虚函数表指针vptr分步初始化
从上面例子，创建子类对象时，编译器的执行顺序：
- 对象在创建时，由编译器对虚函数表指针进行初始化
- 子类构造函数先调用父类构造函数，这个时候虚函数表指针先指向父类的虚函数表
- 子类构造的时候，虚函数表指针再指向子类的虚函数表
- 对象创建完成之后，虚函数表指针最终的指向才确定
为什么存在继承的时候，析构函数要写成虚函数
构造函数的调用顺序：自上而下
- 当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达最底层目标派生类的构造函数
析构函数的调用顺序：自下而上
- 当删除一个对象时，首先调用该派生类的析构函数，然后调用上一层基类的析构函数，依次类推，直到到达最顶层的基类析构函数
代码演示
#include <iostream>
using namespace std;
class Base {
public:
Base() { cout << "创建Base基类。" << endl; }
~Base() { cout << "删除Base基类。" << endl; }
};
class Child : public Base {
public:
Child() { cout << "创建Child派生类。" << endl; }
~Child() { cout << "删除Child派生类。" << endl; }
};
int main() {
cout << "*********构造函数调用顺序示例***********" << endl;
Child *C1 = new Child;//派生类指针指向派生类对象
cout << "*********析构函数调用顺序示例***********" << endl;
delete C1;
}
-
输出结果
创建Base基类。 创建Child派生类。 *********析构函数调用顺序示例*********** 删除Child派生类。 删除Base基类。
虚析构函数的作用
通过基类指针来删除派生类对象时，基类的析构函数应该是虚函数
- 在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。如果要用基类对继承成员进行操作，则要把基类的这个成员函数定义为虚函数，析构函数同样需要如此。
- 如果要用基类指针来删除派生类的对象，而这个基类有一个非虚的析构函数。后果是对象的派生部分不会被销毁。然而基类部分被销毁了，将导致内存泄露。
基类析构函数不是虚函数，则析构的时候子类对象没有析构
#include <iostream>
using namespace std;
class Base {
public:
Base() { cout << "创建Base基类。" << endl; }
~Base() { cout << "删除Base基类。" << endl; } //析构函数不是虚函数
};
class Child : public Base {
public:
Child() { cout << "创建Child派生类。" << endl; }
~Child() { cout << "删除Child派生类。" << endl; }
};
int main() {
cout << "*********构造函数调用顺序示例***********" << endl;
Base *C1 = new Child;//基类指针指向派生类对象
cout << "*********析构函数调用顺序示例***********" << endl;
delete C1;
}
-
输出结果
*********构造函数调用顺序示例*********** 创建Base基类。 创建Child派生类。 *********析构函数调用顺序示例*********** 删除Base基类。
基类析构函数是虚函数，子类对象和父类对象都被析构
#include <iostream>
using namespace std;
class Base {
public:
Base() { cout << "创建Base基类。" << endl; }
virtual ~Base() { cout << "删除Base基类。" << endl; } //虚析构函数
};
class Child : public Base {
public:
Child() { cout << "创建Child派生类。" << endl; }
~Child() { cout << "删除Child派生类。" << endl; }
};
int main() {
cout << "*********构造函数调用顺序示例***********" << endl;
Base *C1 = new Child;
cout << "*********析构函数调用顺序示例***********" << endl;
delete C1;
}
-
输出结果
*********构造函数调用顺序示例*********** 创建Base基类。 创建Child派生类。 *********析构函数调用顺序示例*********** 删除Child派生类。 删除Base基类。