文章目录
前言
多态,顾名思义,就是一件事物具备不同的形态
,是继承之后,面向对象的第三大特性
,可以这样说:有了继承才有了类的多态,而类的多态是为了更好的实现继承。
多态的列车即将起航,不知你准备好了吗?
一、概念
继承与多态相辅相成
。
举个例子:
我们都是人(具备人都有的信息——性别,年龄等),在社会上我们又会具备不同的身份——老师,学生,工人等,那这时放假回家,要去买火车票,那这时如果你是学生火车票五折
。如果是老师火车票七五折
。
老师和学生都是人,人又具有不同的身份,而不同身份面临的同一件事情表现的具体形态不同。
因此:老师和学生继承人的信息,从而使不同的事物(具有相同特征)对同一件事表现出不同的形态,这样就是多态。
补充:
网友比较形象的解释:
英雄联盟里的每个英雄都是一个对象,其父类(基类)有个方法:按Q、W、E、R会产生伤害、消耗蓝量、并在屏幕上显示攻击效果,每个对象(英雄)继承这个方法,并具有具体的属性,每个对象的伤害量不同、消耗蓝量不同,产生的效果不同,而这个方法具有多态,在编写代码和编译的时候并不确定,而在运行的时候,依据你选则了哪个英雄(对象),在调用父类的这个方法的时候,会依据具体对象执行能产生不同状态的方法,也就是说这个父类的方法具有了多种状态,想要其产生新的状态,只需基于父类再编写新的对象
那语法层面上是如何实现多态呢?
1.分类
多态,我们其实已经接触过一种,叫函数重载
,根据传参不同而调用同一函数的不同形态。这叫做静态的多态,也叫静态绑定
,而我们今天讲的主要是在继承之后延伸出的类的多态,叫动态的多态,也叫动态绑定
。
这里根据上面的例子,列出一段代码:
#include<iostream>
using namespace std;
class Person
{
public:
virtual void BuyTickets()
{
cout << "全价" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTickets()
{
cout << "学生->半价" << endl;
}
};
class Teacher : public Person
{
public:
virtual void BuyTickets()
{
cout << "老师->七五折" << endl;
}
};
void BuyTicket(Person & per)
{
per.BuyTickets();
}
int main()
{
Student stu;
Teacher tea;
BuyTicket(stu);
BuyTicket(tea);
return 0;
}
运行结果如下:
初学者看懂个大概即可,语法和原理下面会细讲。
2.实现条件
主要实现方法有两个。
①重写虚函数
- 所谓虚函数,就是在函数的前面加上
virtual
。
那重点就在于重写,也叫覆盖。
如何才能构成重写呢?或者什么叫做重写呢?
- 首先父类至少得有虚函数。
- 一般来说,子类虚函数得跟父类的虚函数的函数名,参数类型,返回类型相同,简称三同。
细节:
- 子类的函数前可不加virtual。
- 返回类型可以不同,但是必须是父子类的指针或者引用,且父类只能是父类的指针或者引用,子类必须是子类的指针或者引用。 ——
协变
- 重写的是实现。
到这重写的条件就讲清了,至于什么叫重写,其实很简单就是:在达成重写的条件下,子类的虚函数替换掉父类的虚函数,从而达成用指向子类的父类指针,在调用此虚函数时,会调用子类的虚函数,而不是父类的虚函数。
列一段代码,看结果便可明了。
#include<iostream>
using namespace std;
class Person
{
public:
//其它类的引用和指针也行,但必须是父是父的,子是子的!
virtual Person* BuyTickets(int val1 = 1)
{
cout << "全价" << endl;
cout << val1 << endl;
return nullptr;
}
};
class Student : public Person
{
public:
virtual Student* BuyTickets(int val2 = 0)
{
cout << "学生->半价" << endl;
cout << val2 << endl;
return nullptr;
}
};
class Teacher : public Person
{
public:
virtual Teacher* BuyTickets(int val3 = - 1)
{
cout << "老师->七五折" << endl;
cout << val3 << endl;
return nullptr;
}
};
void BuyTicket(Person & per)
{
per.BuyTickets();
}
int main()
{
Student stu;
Teacher tea;
BuyTicket(stu);
BuyTicket(tea);
return 0;
}
运行结果如下:
- 解释细节3:壳还是套的父类,仅仅改变了作用域和实现, 如果便于理解,你也可以认为参数名也改了——但实际上
底层用的是地址和寄存器,根本不关心参数名
,这也是细节1的原因。
1.1总结三重
1.2 final与override
- override——对虚函数的重写进行检查。
class Student : public Person
{
public:
Student* BuyTickets (int val2 = 0) override
{
cout << "学生->半价" << endl;
cout << val2 << endl;
return nullptr;
}
//void fun1() override
//{
//}
//
//此注释代码不符合重写条件,故报错。
};
- final
- 禁止派生类重写此虚函数
class Person
{
public:
virtual void BuyTickets()final
{
cout << "全价" << endl;
}
};
class Student : public Person
{
public:
//因为此函数构成重写,派生类会重写虚函数,因此会报错。
void BuyTickets ()
{
cout << "学生->半价" << endl;
}
};
- 禁止此类被继承(语法层面) —— C++11
class A final
{};
//因为B继承A,所以会报错。
class B : public A
{};
C++98采用构造函数/析构函数私有来进行实现不可被继承(应用层面)。
- 构造私有
class A
{
public:
static A* CreatObj()
{
return new A;
}
private:
A()
{}
};
class B : public A
{
//原理为父类的私有成员在派生类中不可见。
};
int main()
{
A* a = A::CreatObj();
//B b;报错
return 0;
}
- 析构私有
class A
{
public:
void Destory()
{
A::~A();
}
private:
~A()
{}
};
class B : public A
{
public:
//原理为父类的私有成员在派生类中不可见。
};
int main()
{
A* ptra = new A;
ptra->Destory();
operator delete (ptra);
//B b;
//报错
return 0;
}
②父类的指针或者引用
为啥必须是父类的指针和引用呢?
从概念上理解,是人具有多种形态,而不是老师具有多种形态,因为人是比较抽象的,赋予了某种身份才具象化。
再换一个例子,是植物具有多种形态,还是玫瑰花具有多种形态?其原因还是一样的,植物没有赋予固定的形态,是比较抽象的,而给植物赋予玫瑰花的身份是具象的。
- 所以父类这种比较抽象的状态是符合多态的。 当然从C++语法上来说父类也可以是具体的。 但都是
为了改变父类的指向从而调用父类的虚函数
。
补充:
子类也可以有多种形态,这是把子类当做父类来看的,就比如动物里面有猫,而猫分为很多种,比如波斯猫,布偶猫等。
细节: 指定作用域,可破坏多态的条件:
void BuyTicket(Person & per)
{
per.Person::BuyTickets();
}
-
为啥不能是子类的指针或者引用?
-
为啥不是是父类对象?(涉及原理之后再讲)
2.1普通调用VS多态调用
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
int _a = 0;
};
class B
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
};
class C : public A, public B
{
public:
virtual void fun1()
{
cout << "C::fun1()" << endl;
}
};
int main()
{
C c;
//普通调用
c.fun1();
//多态调用
B* b = &c;
b->fun1();
//看汇编代码之后,想一下为什么,不构成多态也去虚函数里面找,再进行调用。
C* ptrc = &c;
return 0;
}
汇编图解:
3.抽象类
3.1. 纯虚函数
- 在虚函数后面加上 “= 0” 即为纯虚函数,切记语法规定只能是0。
class A
{
public:
virtual void fun1() = 0;
};
纯虚函数所在类是不能实例化的。
补充:空函数——实现啥也没有
如:void func() {}
class B : public A
{}
这里B继承了A,纯虚函数也被继承了,因此B也无法进行实例化。
像这样,有纯虚函数的类,就是抽象类。
那如何使用呢?很简单子类将纯虚函数进行重写,不就能使用了么。
- 因此抽象类,会强制子类重写虚函数(应用)。
class B : public A
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
};
B进行重写后,就不含纯虚函数,也就不是抽象类了。
如果你执意要调用,也是可以的,不过会报错:
int main()
{
B b;
A* a = &b;
a->fun1();
return 0;
}
3.2. 接口继承和实现继承
- 普通的继承,直接对成员函数进行复用,俗称接口继承。
- 多态的继承,对虚函数进行重写,重写的是实现。俗称实现继承。
二、原理及使用
1.虚函数表 —— 虚表
引入:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{}
private:
char _a = 1;
};
int main()
{
A a;
cout << sizeof(A) << endl;
return 0;
}
运行结果:
为啥不是4(8字节对齐)呢?难道多了什么吗?
查看监视窗口:
调用构造函数前~
调用构造函数后~
- 首先在构造函数调用前,比我们预想多了一个指针,是void** 类型的,并且没有被初始化。这就足以证明,8字节是咋来的了。
- 在调用构造函数后,可以看到_vftptr的指针的具体信息,并被初始化了,大概是_vftptr指针指向的是一个数组,数组有两个元素,元素所存的元素的类型为void (*) ()的虚函数指针,也就是一张存放函数指针的表。且最后一个位置存放的应该是虚函数表的结束位置。
之后证明
。
那这张存放虚函数的表,我们称之为虚函数表,简称虚表。
那虚表是用来干啥呢?当然是肯定是用来实现多态的了,再说细点就是为了实现重写。
既然是这样,那我们对以下代码进行调试。
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{}
virtual void fun2()
{}
private:
char _a = 1;
};
class B : public A
{
public:
virtual void fun1()
{}
};
int main()
{
A a;
B b;
return 0;
}
调试结果:
- 很显然,不同类的虚表是不同的。根据虚表指针存的值即可看出 。
- 当子类生成虚表时,把子类的虚表拷贝下来,然后对构成重写的虚函数进行覆写,这里是对原来的位置进行覆盖实现。而子类的不构成重写的虚函数则继续在虚表的后面进行排列。
- 至于这里监视窗口为啥看不到fun3,我的理解是监视窗口是站在父类的角度进行查看的,当然只能看到父类重写的虚函数和父类没有被重写的虚函数,如果能看到子类的虚函数不就怪了吗?
至于如何验证第三个位置是fun3,给出如下代码。
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << " A :: fun1()" << endl;
}
virtual void fun2()
{
cout << " A :: fun2()" << endl;
}
private:
int _a = 1;
};
class B : public A
{
public:
virtual void fun1()
{
cout << " B :: fun1()" << endl;
}
virtual void fun3()
{
cout << " B :: fun3()" << endl;
}
int _b = 1;
};
typedef void (*FUN_PTR)();
void Print(FUN_PTR * arr)
{
for (size_t i = 0; arr[i] != nullptr; i++)
{
printf("%p->", arr[i]);
FUN_PTR ptr = arr[i];
ptr();
}
}
int main()
{
B b;
int ptr = *(int*)(&b);
Print((FUN_PTR*)ptr);
return 0;
}
运行结果:
这是虚表的内存地址(小端):
总结一下:
- 不同类的虚表指针的值是不同的。相同类的虚表指针的值是相同的。(不再证明,有兴趣自己看监视窗口)。
- 监视窗口看不到fun3, 是因为站的视角为父类,而fun3是子类的。
- vs2019虚表的结束位置为 0
- 子类虚表先放父类(虚函数),再重写,再放子类(从上往下)。
- 虚表指针随着构造函数的调用而初始化,且虚表指针在对象模型的第一个位置。
下面我们继续讨论遗留下来的问题:
- 为啥不是是父类对象?
class A
{
public:
virtual void fun1()
{}
};
class B : public A
{
public:
virtual void fun1()
{}
};
int main()
{
A a;
B b;
a = b;
//拷贝不拷贝虚表?
return 0;
}
我们只看赋值之后的监视窗口:
- 可见,虚表是不会被拷贝过去的,因此,无法完成指向父类调子类的情况(多态),并且如果拷贝过去子类能调用父类的虚函数,就乱套了!因此是不拷贝虚表的。
- 为啥不是是父类对象?
那虚表存在哪呢?给出如下代码进行验证。
#include<iostream>
class A
{
public:
virtual void fun1()
{}
};
int main()
{
A a;
//虚表的地址
void** ptr = (void**)(*(int*)&a);
//栈区的地址
int _a = 0;
//静态区的地址
static int b = 0;
//常量区地址
const char* str = "abc";
//堆的地址
int* ptr1 = new int;
printf("虚表地址->%p\n", ptr);
printf("栈区地址->%p\n", &_a);
printf("堆区地址->%p\n", ptr1);
printf("静态区地址->%p\n", &b);
printf("常量区地址->%p\n", str);
return 0;
}
运行结果:
- 可见虚表地址与常量区地址仅仅差8个字节。
- 因此:虚表至少在VS2019下是存在常量区的。
2.默认成员函数
2.1构造函数
- 语法上,不允许在构造函数前加virtual。
那为什么呢?
利用之前得到的结论,虚表指针是在构造函数调用时才被初始化的! 如果构造函数是虚函数,那虚表指针都没有初始化,如何调用虚函数呢?典型的先有虚函数指针 还是 先调用构造函数的问题。因此语法上禁掉了。
除此之外,构造(包括拷贝构造)函数里面调用成员函数,不会从虚表进行调用,而是直接进行调用!
2.2析构函数
- 语法上,允许在析构函数前加virtual。
这是为啥呢?
举一段错误代码,一看便知:
#include<iostream>
using namespace std;
class A
{
public:
~A()
{
cout << "A::~A()" << endl;
}
int _a = 0;
};
class B : public A
{
public:
~B()
{
cout << "B::~B()" << endl;
}
int _b = 1;
};
int main()
{
B* b = new B;
A* a = b;
delete a;
return 0;
}
运行结果 :
- 很明显的问题出来了,竟然没有调用子类的析构函数。这是由于向上转换发生的切割现象。会导致内存泄漏的问题。
如何解决?
- 析构函数前加virtual,那假设上面的代码加上virtual,那delete 子类指针会形成多态,指向父类调用父类的析构函数,指向子类调用子类的析构函数。
3. 多继承
3.1普通的多继承 + 虚函数
举出如下代码进行实验:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
virtual void fun2()
{
cout << "A::fun2()" << endl;
}
int _a = 0;
};
class B
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
virtual void fun2()
{
cout << "B::fun2()" << endl;
}
int _b = 0;
};
class C : public A ,public B
{
public:
virtual void fun1()
{
cout << "C::fun1()" << endl;
}
virtual void fun3()
{
cout << "C::fun3()" << endl;
}
int _c = 0;
};
typedef void (*FUN_PTR)();
void Print(FUN_PTR * arr)
{
for (size_t i = 0; arr[i] != nullptr; i++)
{
printf("%p->", arr[i]);
FUN_PTR ptr = arr[i];
ptr();
}
cout << endl;
}
int main()
{
C c;
void** vftptr1 = (void **)(*(int*)(&c));
B* ptr = &c;
void** vftptr2 = (void **)(*(int*)(ptr));
Print((FUN_PTR*)vftptr1);
Print((FUN_PTR*)vftptr2);
return 0;
}
首先我们要看初始化之后的类C的对象模型
:
- 细节:可以根据_vfptr的的信息看出有几个元素。这里A的有四个,B的有三个。
根据此画出对象模型:
运行结果:
- 总结:继承的子类的不构成重写虚函数不会再生成虚表(除非没有),
而是将虚函数放在第一个父类的虚表中
;多继承父类不共享虚表,而是各用个的。
除此之外,这里还会衍生出一个问题:运行结果C::fun1()的地址竟然不同,这是为什么呢?
将上述代码进行简化:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
int _a = 0;
};
class B
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
};
class C : public A, public B
{
public:
virtual void fun1()
{
cout << "C::fun1()" << endl;
}
};
int main()
{
C c;
B* b = &c;
A* a = &c;
a->fun1();
b->fun1();
return 0;
}
调用函数的反汇编流程图:
- 可见,b对象在调用真正的fun1时拐了一个弯,然后再调用fun1。
为啥要这样这样做呢?
- 看关键动作——对ecx减8,ecx存放的是this指针,对this指针减8,到C对象的this指针位置,通过C的this指针再进行调用fun1。为啥要这样做呢?因为fun1的作用域是C的类域,直接用B的this指针显然不合理。
- 因此:调整B的this指针是为了类域的独立性,那A对象咋不用呢?因为A的this指针本就可以当做D的this指针进行使用,没必要再偏。
3.2菱形继承 + 虚函数
同样给出一段代码实验:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
int _a = 0;
};
class B : public A
{
public:
virtual void fun1()
{
cout << "B::fun1()" << endl;
}
virtual void fun2()
{
cout << "B::fun2()" << endl;
}
int _b = 0;
};
class C : public A
{
public:
virtual void fun1()
{
cout << "C::fun1()" << endl;
}
virtual void fun2()
{
cout << "C::fun2()" << endl;
}
int _c = 0;
};
class D : public B , public C
{
public:
virtual void fun2()
{
cout << "D::fun2()" << endl;
}
virtual void fun3()
{
cout << "D::fun3()" << endl;
}
};
typedef void (*FUN_PTR)();
void Print(FUN_PTR * arr)
{
for (size_t i = 0; arr[i] != nullptr; i++)
{
printf("%p->", arr[i]);
FUN_PTR ptr = arr[i];
ptr();
}
cout << endl;
}
int main()
{
D d;
void** vftptr1 = (void**)(*((int*)(&d)));
C* b = &d;
void** vftptr2 = (void**)(*((int*)(b)));
Print((FUN_PTR*)vftptr1);
Print((FUN_PTR*)vftptr2);
return 0;
}
初始化对象后的D类的监视窗口:
运行结果:
据此画出D类对象的对象模型:
- 其实跟多继承差不多,也就多套了一层,这里解释一下,B类的fun1重写A类的fun1,D类的fun2重写B类的fun2,D类的fun3放在第一个父类对象的虚表中。C类同理这里就不多说了。
3.3菱形虚拟继承 + 虚函数
贴出一段代码进行实验:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
int _a = 0;
};
class B : virtual public A
{
public:
virtual void fun2()
{
cout << "B::fun2()" << endl;
}
int _b = 0;
};
class C : virtual public A
{
public:
virtual void fun2()
{
cout << "C::fun2()" << endl;
}
int _c = 0;
};
class D : public B , public C
{
public:
virtual void fun3()
{
cout << "D::fun3()" << endl;
}
virtual void fun4()
{
cout << "D::fun4()" << endl;
}
int _d = 0;
};
typedef void (*FUN_PTR)();
void Print(FUN_PTR * arr)
{
for (size_t i = 0; arr[i] != nullptr; i++)
{
printf("%p->", arr[i]);
FUN_PTR ptr = arr[i];
ptr();
}
cout << endl;
}
int main()
{
D d;
void** vftptr1 = (void**)(*((int*)(&d)));
C* b = &d;
void** vftptr2 = (void**)(*((int*)(b)));
A* a = &d;
void** vftptr3 = (void**)(*((int*)(a)));
Print((FUN_PTR*)vftptr1);
Print((FUN_PTR*)vftptr2);
Print((FUN_PTR*)vftptr3);
return 0;
}
d初始化后的监视窗口:
运行结果:
结合内存画出对象模型:
- D单独的虚函数放在第一张虚表中,如果除A的虚表外,没有虚表可以放,那就放自己的虚表中。
- B,C的各自的虚函数,分别存在两张虚表中。
- A,存放一张虚表。
- 类对象第一个位置存放的是虚表指针,而不是虚基表指针。 因此虚基表指针指向的第一个位置变成了
ff ff ff fc
,转换成int
也就是- 4
,这是虚表指针的地址相对类的this指针偏移量(this指针 - 虚表指针的地址)。
第二个位置存的是虚表指针的地址相对于A的偏移量
。第三个位置存的是0,个人理解:表示终止位置
。
此外,我们还需注意避免不同子类重写基类的问题:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{}
};
class B : virtual public A
{
public:
virtual void fun1()
{}
};
class C : virtual public A
{
public:
virtual void fun1()
{}
};
class D : public B, public C
{
public:
virtual void fun2()
{}
};
编译结果:
画个图理解一下:
- 问题:二义性,A不知该继承谁的。
- 解决方法:交给孙子类决定。
代码如下:
class A
{
public:
virtual void fun1()
{}
int _a = 0;
};
class B : virtual public A
{
public:
virtual void fun1()
{}
int _b = 0;
};
class C : virtual public A
{
public:
virtual void fun1()
{}
int _c = 0;
};
class D : public B, public C
{
public:
virtual void fun1()
{}
virtual void fun2()
{}
int _d;
};
4.inline与static
4.1inline
补充知识:
1.内联函数,可以说不是函数,是一段代码。
2.类里面的成员函数,默认inline修饰。
3. inline修饰函数,不一定是内联函数,取决于函数的实现是否复杂,最终还是要编译器决定的。但内联函数一定是被inline修饰的!
- 虚函数前是可以加inline的,但其不是内联函数,原因是因为虚函数是需要被放在虚表中的。
4.2 static
- static是不能修饰虚函数的,其原因在于
虚函数是为了实现多态的
,而多态的条件是父类的指针或者引用,其本质上都是传了子类的this指针,但static修饰的函数是没有this指针的
,无法实现多态,因此不能用static修饰虚函数。
总结
今天的分享就到这里了,如果觉得文章不错,点个赞鼓励一下吧!我们下篇文章再见
!