目录
多态是C++面向对象三大特性之一。
一、多态基本概念
1. 多态的分类
- 静态多态：函数重载和运算符重载属于静态多态
- 动态多态：派生类和虚函数运行时会产生动态多态
2. 静态多态和动态多态的区别
- 静态多态的函数地址早绑定：程序编译阶段确定函数地址
- 动态多态的函数地址晚绑定：程序运行阶段确定函数地址
3. 动态多态的产生条件及使用
产生条件：
- 有继承关系
- 子类重写父类的虚函数
使用：父类的指针或引用指向子类对象
#include <iostream>
using namespace std;
#include<string>
class A {
public:
//构造函数
A() {
a = 100;
}
virtual void fun() { //在父类中定义虚函数
cout << "父类A的虚函数" << endl;
}
int a;
};
class B : public A {
void fun() { //在子类中重写父类的虚函数
cout << "在子类B中重写的父类虚函数fun。" << endl;
}
};
void func(A &a) {
a.fun();
}
void test() {
B b;
func(b); //将子类对象传给父类的引用
}
int main() {
test();
system("pause");
return 0;
}在子类B中重写的父类虚函数fun。
请按任意键继续. . .4. 多态的内部原理
- 父类定义虚函数时生成vfptr(虚函数指针)指向vftable(虚函数表)，vfptr在类对象中占据4个字节，vftable中存储虚函数的地址：&父类名::虚函数名。
- 子类继承父类时会继承父类的vfptr指针指向子类的vftable。若子类不对父类的虚函数进行重写，则子类的vftable与父类内容相同，存储：&父类名::虚函数名。若子类重写父类的虚函数，则子类的vftable存储的是：&子类名::虚函数名。
- 当父类对象的引用或指针指向子类对象时，对于重写了父类的虚函数的子类，vfptr指向子类vftable，即调用子类重写的函数。此时形成多态。
5. 多态的优点
- 代码结构清晰
- 代码可读性强
- 便于代码后期维护与扩展
二、纯虚函数与抽象类
1. 相关概念与语法
- 纯虚函数的作用：在多态中，通常父类的虚函数的实现是毫无意义的，主要使用子类重写的内容，因此可以将虚函数改为纯虚函数。
- 纯虚函数的语法：virtual 返回值类型 函数名(参数列表) = 0；
- 抽象类：当类中有纯虚函数时，该类就是抽象类。
2. 抽象类特点
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
#include <iostream>
using namespace std;
#include<string>
class A {
public:
//创建纯虚函数
virtual void fun() = 0; //只要有一个纯虚函数，该类就为抽象类，无法实例化
};
class B : public A {
void fun() { //在子类中必须重写父类的纯虚函数，否则该子类也是抽象类无法实例化
cout << "在子类B中重写的父类纯虚函数fun。" << endl;
}
};
void test() {
A * b = new B; //通过父类的指针指向子类的对象
b->fun(); //调用子类B重写的函数fun
}
int main() {
test();
system("pause");
return 0;
}在子类B中重写的父类纯虚函数fun。
请按任意键继续. . .三、虚析构函数与纯析构函数
1. 虚析构函数与纯析构函数的作用
多态使用时，若子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构函数，造成内存泄漏风险。在父类中使用虚析构函数或纯析构函数可以解决这个问题。
2. 特点
虚析构函数与纯析构函数的共性：
- 可以解决父类指针释放子类对象的问题
- 都需要有具体的函数实现
虚析构函数与纯析构函数的区别：
- 不具有纯虚函数成员，仅有虚析构函数，该类不是抽象类
- 具有纯虚析构函数的类时抽象类
3. 语法
- 虚析构函数语法：virtual ~类名(){};
- 纯虚析构函数语法：virtual ~类名() = 0; 并在类外给出其具体实现：类名::~类名(){具体实现代码};
4. 总结
- 虚析构函数与纯析构函数是用来解决通过父类指针释放子类对象
- 若子类中没有属性开辟在堆区，可以不使用虚析构函数或纯析构函数
- 拥有纯虚析构函数的类也属于抽象类
5. 实例
- 不使用虚析构函数与纯析构函数，此时子类的析构函数不会被调用，在子类中有属性开辟到堆区时会出现内存泄漏
#include <iostream>
using namespace std;
class A {
public:
//构造函数
A() {
cout << "父类A的构造函数" << endl;
}
//析构函数
~A() {
cout << "父类A的析构函数" << endl;
}
//纯虚函数
virtual void fun() = 0;
};
class B : public A {
public:
//构造函数
B() {
cout << "子类B的构造函数" << endl;
}
//析构函数
~B() {
if (p != NULL) {
cout << "子类B析构函数" << endl;
delete p;
p = NULL;
}
}
//重写父类的纯虚函数
void fun() {
p = new int(5);
cout << *p << endl;
}
int * p;
};
void test() {
A * A1 = new B;
A1->fun();
delete A1;
}
int main() {
test();
system("pause");
return 0;
}父类A的构造函数
子类B的构造函数
5
父类A的析构函数
请按任意键继续. . .- 父类使用虚构造函数，此时会调用子类的析构函数，能够避免子类中堆区数据释放不彻底的问题
#include <iostream>
using namespace std;
class A {
public:
//构造函数
A() {
cout << "父类A的构造函数" << endl;
}
//虚析构函数
virtual ~A() {
cout << "父类A的析构函数" << endl;
}
//纯虚函数
virtual void fun() = 0;
};
class B : public A {
public:
//构造函数
B() {
cout << "子类B的构造函数" << endl;
}
//析构函数
~B() {
if (p != NULL) {
cout << "子类B析构函数" << endl;
delete p;
p = NULL;
}
}
//重写父类的纯虚函数
void fun() {
p = new int(5);
cout << *p << endl;
}
int * p;
};
void test() {
A * A1 = new B;
A1->fun();
delete A1;
}
int main() {
test();
system("pause");
return 0;
}父类A的构造函数
子类B的构造函数
5
子类B析构函数
父类A的析构函数
请按任意键继续. . .- 父类使用纯虚析构函数，此时也会调用子类的析构函数，进而避免子类中堆区数据释放不彻底的问题。但要注意需要在类外给出纯虚析构函数的具体实现。
#include <iostream>
using namespace std;
class A {
public:
//构造函数
A() {
cout << "父类A的构造函数" << endl;
}
//纯虚析构函数
virtual ~A() = 0;
//纯虚函数
virtual void fun() = 0;
};
//类外给出纯虚析构函数的实现
A::~A() {
cout << "父类A的析构函数" << endl;
}
class B : public A {
public:
//构造函数
B() {
cout << "子类B的构造函数" << endl;
}
//析构函数
~B() {
if (p != NULL) {
cout << "子类B析构函数" << endl;
delete p;
p = NULL;
}
}
//重写父类的纯虚函数
void fun() {
p = new int(5);
cout << *p << endl;
}
int * p;
};
void test() {
A * A1 = new B;
A1->fun();
delete A1;
}
int main() {
test();
system("pause");
return 0;
}父类A的构造函数
子类B的构造函数
5
子类B析构函数
父类A的析构函数
请按任意键继续. . .
639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
