一、为什么要使用多态
因为各种不确定原因，包括人为原因，电脑会自动切换到其他类型的蓝牙耳机，而切换的蓝牙耳机与原蓝牙耳机不是一样的，和其有着很多不同的地方，那么如何完美的实现这个切换呢？
解决方案：
使用多态。
案例：父亲与儿子都有play方法，但是内容不一样，当父类指针指向儿子指针调用方法时，都还是调用的父类方法。
即使“替父从军”，但是还是想做自己的事情，就要用到多态。
#include <iostream>
using namespace std;
class Father {
public:
void play() {
cout << "到KTV唱歌..." << endl;
}
};
class Son :public Father {
public:
void play() {
cout << "一起打王者吧！" << endl;
}
};
void party(Father **men, int n) {
for (int i = 0; i<n; i++) {
men[i]->play();
}
}
int main(void) {
Father father;
Son son1, son2;
Father* men[] = { &father, &son1, &son2 };
party(men, sizeof(men) / sizeof(men[0]));
system("pause");
return 0;
}
解决方案:
通过虚函数，实现多态。在父类中加上virtual，子类可加可不加。
.........
class Father {
public:
virtual void play() {
cout << "到KTV唱歌..." << endl;
}
};
class Son :public Father {
public:
virtual void play() {
cout << "一起打王者吧！" << endl;
}
};
.........
二、实现多态：虚函数
多态的本质与虚函数的使用
多态的本质：
形式上，使用统一的父类指针做一般性处理，
但是实际执行时，这个指针可能指向子类对象，
形式上，原本调用父类的方法，但是实际上会调用子类的同名方法。
【注意】
程序执行时，父类指针指向父类对象，或子类对象时，在形式上是无法分辨的！
只有通过多态机制，才能执行真正对应的方法。
基础：虚函数的使用
虚函数的定义：
在函数的返回类型之前使用virtual
只在成员函数的声明中添加virtual, 在成员函数的实现中不要加virtual
虚函数的继承：
- 如果某个成员函数被声明为虚函数，那么它的子类【派生类】，以及子类的子类中，所继承的这个成员函数，也自动是虚函数。
- 如果在子类中重写这个虚函数，可以不用再写virtual, 但是仍建议写virtual, 更可读！
1.虚函数的原理-虚函数表
①单个类的虚函数表–看类中的内存分布
定义一个Father类，在这个类中内存如何分布？
虚函数表应该存储在Father的对象中。
内存分布图析：
虚函数指针指向虚函数表，虚函数表中放函数的地址，最后又指向函数的实现。
同一类的对象都指向同一虚函数表。虚函数表不在对象内存空间中。
对象内，首先存储的是“虚函数表指针”，又称“虚表指针”。
然后再存储非静态数据成员。
对象的非虚函数，保存在类的代码中！
对象的内存，只存储虚函数表和数据成员
（类的静态数据成员，保存在数据区中，和对象是分开存储的）
添加虚函数后，对象的内存空间不变！仅虚函数表中添加条目
多个对象，共享同一个虚函数表！
#include <iostream>
using namespace std;
class Father {
public:
virtual void func1() { cout << "Father::func1" << endl; }
virtual void func2() { cout << "Father::func2" << endl; }
virtual void func3() { cout << "Father::func3" << endl; }
void func4() { cout << "非虚函数：Father::func4" << endl; } //类代码中
public: //为了便于测试，特别该用public
int x = 100;
int y = 200;
static int z; //数据区
};
typedef void (*func_t)(void);
int Father::z = 1;
int main(void) {
Father father;
// 含有虚函数的对象的内存中，最先存储的就是“虚函数表”，所以对象地址就是虚函数地址，转为int*是想让编译器用16进制方式打印
cout << "对象地址：" << (int*)&father << endl;
int* vptr = (int*)*(int*)&father;//对象地址转换为int类型指针，根据指针值取出一个数据，最后的(int *)用来强转，因为前面说的其实是个int值，这里让编译器能通过。
cout << "虚函数表指针vptr：" << vptr << endl;
cout << "调用第1个虚函数: ";
((func_t) * (vptr + 0))(); //函数指针
cout << "调用第2个虚函数：";
((func_t) * (vptr + 1))();
cout << "调用第3个虚函数: ";
((func_t) * (vptr + 2))();
cout << "第1个数据成员的地址: " << endl;
cout << &father.x << endl;
cout << std::hex << (int)&father + 4 << endl; //转为16进制，虚函数指针占4个字节，所以向下偏移4个字节的地址，转int型是因为这样才能偏移4个字节。如果不加那么就是指针的加减，加4个指针了。
cout << "第1个数据成员的值：" << endl;
cout << std::dec << father.x << endl; //转为10进制
cout << *(int*)((int)&father + 4) << endl; //先拿到地址，通过强转后拿到地址对应的值
cout << "第2个数据成员的地址: " << endl;
cout << &father.y << endl;
cout << std::hex << (int)&father + 8 << endl;
cout << "第2个数据成员的值：" << endl;
cout << std::dec << father.y << endl;
cout << *(int*)((int)&father + 8) << endl;
cout << "sizeof(father)==" << sizeof(father) << endl;
Father father2;
cout << "father的虚函数表：";
cout << *(int*)(*(int*)&father) << endl;
cout << "father2的虚函数表：";
cout << *(int*)(*(int*)&father2) << endl;
system("pause");
return 0;
}
执行效果：
VS的对象内存分布分析：
项目的命令行配置中添加： /d1 reportSingleClassLayoutFather
这里可以看到虚函数表指针占4个字节、两个成员变量各占4各字节。虚函数表中有三个父类的虚函数。
②使用继承的虚函数表–看虚函数效果
加了一个Son派生类，重写func1，增加自己的虚函数func5
内存分布：
#include <iostream>
using namespace std;
class Father {
public:
virtual void func1() { cout << "Father::func1" << endl; }
virtual void func2() { cout << "Father::func2" << endl; }
virtual void func3() { cout << "Father::func3" << endl; }
void func4() { cout << "非虚函数：Father::func4" << endl; }
public: //为了便于测试，特别该用public
int x = 100;
int y = 200;
};
class Son : public Father {
public:
void func1() { cout << "Son::func1" << endl; }
virtual void func5() { cout << "Son::func5" << endl; } //为之后该类的派生类所写的虚函数
};
typedef void (*func_t)(void);
int main(void) {
Father father;
Son son;
// 含有虚函数的对象的内存中，最先存储的就是“虚函数表”
cout << "son对象地址：" << (int*)&son << endl;
int* vptr = (int*)*(int*)&son;
cout << "虚函数表指针vptr：" << vptr << endl;
for (int i = 0; i < 4; i++) {
cout << "调用第" << i + 1 << "个虚函数：";
((func_t) * (vptr + i))();
}
for (int i = 0; i < 2; i++) {
// +4 是因为先存储了虚表指针
cout << *(int*)((int)&son + 4 + i * 4) << endl;
}
system("pause");
return 0;
}
执行效果：
补充子类的虚函数表的构建过程：
所以也就是说，多态就是看，当前的这个虚函数是谁的对象调用的，谁的对象调用的，就到谁的虚函数表中去查找调用。（编译器虚函数的实现效果）
③多重继承的虚函数表
增加Mother类，让Son同时继承于父类和母类，可以看到，Son会创建两张虚函数表。
内存分布：
先继承父类的虚函数表，然后进行替换增加，然后继承母类的虚函数表，进行替换增加。
#include <iostream>
using namespace std;
class Father {
public:
virtual void func1() { cout << "Father::func1" << endl; }
virtual void func2() { cout << "Father::func2" << endl; }
virtual void func3() { cout << "Father::func3" << endl; }
void func4() { cout << "非虚函数：Father::func4" << endl; }
public:
int x = 200;
int y = 300;
static int z;
};
class Mother {
public:
virtual void handle1() { cout << "Mother::handle1" << endl; }
virtual void handle2() { cout << "Mother::handle2" << endl; }
virtual void handle3() { cout << "Mother::handle3" << endl; }
public: //为了便于测试，使用public权限
int m = 400;
int n = 500;
};
class Son : public Father, public Mother {
public:
void func1() { cout << "Son::func1" << endl; }
virtual void handle1() { cout << "Son::handle1" << endl; }
virtual void func5() { cout << "Son::func5" << endl; }
};
int Father::z = 0;
typedef void(*func_t)(void);
int main(void) {
Son son;
int* vptr = (int*) * (int*)&son;
cout << "第一个虚函数表指针：" << vptr << endl;
for (int i = 0; i < 4; i++) {
cout << "调用第" << i + 1 << "个虚函数:";
((func_t) * (vptr + i))();
}
for (int i = 0; i < 2; i++) {
cout << *(int*)((int)&son + 4 + i * 4) << endl;
}
int* vptr2 = (int*) * ((int*)&son + 3);
for (int i = 0; i < 3; i++) {
cout << "调用第" << i + 1 << "个虚函数:";
((func_t) * (vptr2 + i))();
}
for (int i = 0; i < 2; i++) {
cout << *(int*)((int)&son + 16 + i * 4) << endl;
}
system("pause");
return 0;
}
执行结果
VS分析：
2.final用于类或虚函数
【C++11】
用来修饰类，让该类不能被继承
理解：使得该类终结！
class XiaoMi {
public:
XiaoMi(){}
};
class XiaoMi2 final : public XiaoMi {
XiaoMi2(){}
};
class XiaoMi3 : public XiaoMi2 { //不能把XiaoMi2作为基类
};
用来修饰类的虚函数，使得该虚函数在子类中，不能被重写
****注意：仅能用于修饰虚函数。
理解：使得该功能终结！
class XiaoMi {
public:
virtual void func() final;
};
void XiaoMi::func() { //不需要再写final
cout << "XiaoMi::func" << endl;
}
class XiaoMi2 : public XiaoMi {
public:
void func() {}; // 错误！不能重写func函数
};
3.override用于虚函数
【C++11】
override仅能用于修饰虚函数。
作用：
- 提示程序的阅读者，这个函数是重写父类的功能。使得代码更加规范
- 防止程序员在重写父类的函数时，把函数名写错。
override只需在函数声明中使用，不需要在函数的实现中使用。
#include <iostream>
using namespace std;
class XiaoMi {
public:
virtual void func() { cout << "XiaoMi::func" << endl; };
};
class XiaoMi2 : public XiaoMi {
public:
void func() override {}
//void func() override; 告诉程序员func是重写父类的虚函数
//void func1() override{} 错误！因为父类没有func1这个虚函数
};
int main(void) {
XiaoMi2 xiaomi;
return 0;
}
三、子类析构函数
在Father类中构造函数进行空间的申请，析构函数中释放空间。Son类也是一样。
当没有给父类的析构函数加上虚函数关键字时，那么当Father类指针指向一个子类的对象，然后进行删除，会发现没有执行子类的析构函数，导致内存泄漏。
解决方案：利用virtual的另外一个特殊功能（本来是重写），见下：
#include <iostream>
#include <Windows.h>
#include <string.h>
using namespace std;
class Father {
public:
Father(const char* addr ="中国"){
cout << "执行了Father的构造函数" << endl;
int len = strlen(addr) + 1;
this->addr = new char[len];
strcpy_s(this->addr, len, addr);
}
// 把Father类的析构函数定义为virtual函数时，
// 如果对 Father类的指针使用delete操作时，
// 就会对该指针使用“动态析构”：
// 如果这个指针，指向的是子类对象，
// 那么会先调用该子类的析构函数，再调用自己类的析构函数
virtual ~Father(){
cout << "执行了Father的析构函数" << endl;
if (addr) {
delete addr;
addr = NULL;
}
}
private:
char* addr;
};
class Son :public Father {
public:
Son(const char *game="吃鸡", const char *addr="中国")
:Father(addr){
cout << "执行了Son的构造函数" << endl;
int len = strlen(game) + 1;
this->game = new char[len];
strcpy_s(this->game, len, game);
}
~Son(){
cout << "执行了Son的析构函数" << endl;
if (game) {
delete game;
game = NULL;
}
}
private:
char* game;
};
int main(void) {
cout << "----- case 1 -----" << endl;
Father* father = new Father();
delete father;
cout << "----- case 2 -----" << endl;
Son* son = new Son();
delete son;
cout << "----- case 3 -----" << endl;
father = new Son();
delete father;
system("pause");
return 0;
}
【注意】
为了防止内存泄露，最好是在基类析构函数上添加virtual关键字，使基类析构函数为虚函数
目的在于，当使用delete释放基类指针时，会实现动态的析构：
如果基类指针指向的是基类对象，那么只调用基类的析构函数
如果基类指针指向的是子类对象，那么先调用子类的析构函数，再调用父类的析构函数
四、纯虚也有用：纯虚函数与抽象类
1.什么时候使用纯虚函数
某些类，在现实角度和项目实现角度，都不需要实例化（不需要创建它的对象），
这个类中定义的某些成员函数，只是为了提供一个形式上的接口，便于实现多态，调用起来更加方便，然后准备让子类来做具体的实现。
此时，这个方法，就可以定义为“纯虚函数”， 包含纯虚函数的类，就称为抽象类。
2.纯虚函数的使用方法
用法：纯虚函数，使用virtual和 =0
例：抽象类-形状类，子类用圆形，
#include <iostream>
#include <string>
using namespace std;
class Shape {
public:
Shape(const string& color = "white") { this->color = color; }
//不用做具体的实现
virtual float area() = 0;
string getColor() { return color; }
private:
string color;
};
//圆形类
class Circle : public Shape {
public:
Circle(float radius = 0, const string& color="White")
:Shape(color), r(radius){}
//纯虚函数做一个实现，如果没有实现，那么该类也还是抽象类不能创建对象
float area();
private:
float r; //半径
};
float Circle::area() {
return 3.14 * r * r;
}
int main() {
//使用抽象类创建对象非法！
//Shape s;
Circle c1(10);
cout << c1.area() << endl;
Shape* p = &c1;
cout << p->area() << endl;
system("pause");
return 0;
}
3.纯虚函数的注意事项
父类声明某纯虚函数后，
那么它的子类，
1）要么实现这个纯虚函数 （最常见）
2）要么继续把这个纯虚函数声明为纯虚函数，这个子类也成为抽象类
3）要么不对这个纯虚函数做任何处理，等效于上一种情况（该方式不推荐）
总结
-
子类在重新实现继承的虚函数时，要和主要函数的原型一致
如果已经继承虚函数：bool heartBeat();
那么重写虚函数时，函数原型必须保持完全一致：bool heartBeat();
而且子类不能添加：int heartBeat();//因为仅函数的返回类型不同时，不能区别两个函数。
但是可以添加：int heartBeat(int); -
析构函数是否使用虚函数
有子类时，析构函数就应该使用虚函数
扫一扫
423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
