C++有五大特性:对象,封装,继承,抽象和多态。而本章则将学习讲解C++中的多态
通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态
普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是优先买票
多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为
被virtual修饰的类成员函数称为虚函数
class Person {
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称子类的虚函数重写了基类的虚函数
class Person {
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person {
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
类虚函数返回基类对象的指针或者引用,派生类虚函数返回派生类对象的指针或者引用时,称为协变(基类与派生类虚函数返回值类型不同)
class A {};
class B : public A {};
class Person {
public:
virtual A* f()
{
cout << "virtual A* f()" << endl;
return new A;
}
};
class Student : public Person {
public:
virtual B* f()
{
cout << "virtual B* f()" << endl;
return new B;
}
};
void Func(Person& p)
{
p.f();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
在重写基类虚函数时,派生类的虚函数在不加virtual关键字也可以构成重写
继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)
class Person {
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person {
public:
//派生类虚函数不加virtual也构成虚函数
void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
class Person {
public:
virtual ~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person {
public:
virtual ~Student()
{
cout << "~Student()" << endl;
}
};
//只有派生类Student的析构函数重写了Person的析构函数
//当delete对象调用析构函数,才能构成多态,才能保证p1和p2指向的对象正确的调用析构函数
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
修饰虚函数,表示该虚函数不能再被重写
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错
class Car{
public:
virtual void Drive(){}
};
class Benz :public Car {
public:
virtual void Drive() override {cout << "Benz-舒适" << endl;}
};
class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
class BMW :public Car
{
public:
virtual void Drive()
{
cout << "BMW-操控" << endl;
}
};
void Test()
{
Car* pBenz = new Benz;
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
}
虽然函数重写需要接口一样,但是对于参数的缺省值没有检查,如果基类虚函数和派生类重写函数的缺省值不同,按照基类虚函数的接口来走,也就是说不用管派生类重写函数的接口
// 这里常考一道笔试题:sizeof(Base)是多少?
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};
b对象是8bytes,除了_b成员,还多一个 _vfptr放在对象的前面
// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
void Func3()
{
cout << "Base::Func3()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
private:
int _d = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}
虚表存的是虚函数指针,不是虚函数,虚函数和普通函数一样的,都是存在代码段的,只是函数的地址存到了虚表中,另外对象中存的是虚表指针,而虚表存在代码段中的(在vs平台下)(可以打印对象的地址与常量,变量进行比较)
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person Mike;
Func(Mike);
Student Johnson;
Func(Johnson);
return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...
p->BuyTicket();
// p中存的是mike对象的指针,将p移动到eax中
001940DE mov eax,dword ptr [p]
// [eax]就是取eax值指向的内容,这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1 mov edx,dword ptr [eax]
// [edx]就是取edx值指向的内容,这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE mov eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用,不是在编译时确定的,是运行起来以后到对象的中取找的
001940EA call eax
001940EC cmp esi,esp
}
int main()
{
...
// 首先BuyTicket虽然是虚函数,但是mike是对象,不满足多态的条件,所以这里是普通函数的调用转换成地址时,是在编译时已经从符号表确认了函数的地址,直接call 地址
mike.BuyTicket();
00195182 lea ecx,[mike]
00195185 call Person::BuyTicket (01914F6h)
...
}
注:我们想看多继承的虚函数表是怎么样的,但是内容窗口是有点问题的(可以认为是编译器设计没考虑到),没办法看到实际的情况,所以这里我们设计特殊的虚函数(返回值,参数相同)并使用打印虚函数表函数进行查看地址和调用验证
class Base1 {
public:
virtual void func1() { cout << "Base1::func1" << endl; }
virtual void func2() { cout << "Base1::func2" << endl; }
private:
int b1;
};
class Base2 {
public:
virtual void func1() { cout << "Base2::func1" << endl; }
virtual void func2() { cout << "Base2::func2" << endl; }
private:
int b2;
};
class Derive : public Base1, public Base2 {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
private:
int d1;
};
typedef void(*VFPTR) ();//这种函数指针的强转是一种特例
void PrintVTable(VFPTR vTable[])
{
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
//取对象地址,(虚函数表指针一般存在对象前四个字节)要取前四个字节地址则用int*进行强转(只能指针类型强转才能改变指针的步长)
//再进行解引用拿到虚函数表指针,然而这样子无法进行传参(类型不匹配),要强转为虚函数指针数组类型
PrintVTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));//先转为char*步长便于越过Base1类去拿到Base2的地址
PrintVTable(vTableb2);
return 0;
}
多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
这里覆盖的地址进行了一次包装,每个地址都指向一个jump,而两个jump存的是同一个虚函数地址
实际中不建议设计出菱形继承及菱形虚拟继承:一方面太复杂容易出问题,另一方面这样的模型,访问基类成员有一定得性能损耗
简单来说,多态是不同对象同种行为产生不同状态 即在不同继承关系的类对象,去调用同一函数,产生了不同的行为
可以,不过编译器会忽略inline属性,这个函数就不再是inline,因为虚函数要放到虚表中去
不能,因为静态成员函数没有this指针,不能通过对象指针找到其虚函数表,使用类型::成员函数的调用方式无法访问虚函数表,所以静态成员函数无法放进虚函数表
不能,因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的,如果构造函数为虚函数,会先在对象中的虚函数查找对应虚函数,而此时虚函数表没有生成(动态多态是运行时绑定)
如果是普通对象,是一样快的 如果是指针对象或者是引用对象,则调用的普通函数快,因为构成多态,运行时调用虚函数需要到虚函数表中去查找
虚函数表是在编译阶段(对象构造时)就生成的,一般情况下存在代码段(常量区)的
注意:不要把虚函数表和虚基表搞混了