深入解析：C++中的多态
目录
1.多态的概念
1.1概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态。
举个简单的例子：比如说买票这种行为，当普通人买票时是全价票，学生买票时是半价票。
2.多态的定义以及实现
2.1多态的构成条件
多态是在不同继承关系的类对象，去调用同一个函数，产生了不同的行为。比如Student也继承了Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：
1.必须通过基类的指针或者引用调用虚函数。
2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
2.2 虚函数
虚函数：即被virtual修饰的类成员函数称之为虚函数。
class Person
{
public:
virtual void BuyTicket()
{
std::cout << "买票全价" << std::endl;
}
};2.3 虚函数的重写
虚函数的重写（覆盖）：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型，函数名称，参数列表完全相同），称子类的虚函数重写了基类的虚函数。
class Person
{
public:
virtual void BuyTicket()
{
std::cout << "买票全价" << std::endl;
}
};
class Student :public Person
{
public:
virtual void BuyTicket()
{
std::cout << "买票半价" << std::endl;
}
};
//注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
//虽然也构成重写（因为继承后基类的虚函数被继承下来，在派生类依旧保持虚函数属性），
//但是该种写法不是很规范，不建议这样使用。
//void BuyTicket() {std::cout<<"买票半价"<
虚函数重写的两个例外：
1.协变（基类与派生类虚函数返回值类型不同）
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）
class A{};
class B :public A{};
class Person
{
public:
virtual A* fun() { return new A; }
};
class Student :public Person
{
public:
virtual B* fun() { return new B; };
};
2.析构函数的重写（基类与派生类析构函数的名字不同）
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
class Person
{
public:
virtual ~Person() { std::cout << "~Person()" << std::endl; }
};
class Student :public Person
{
public:
virtual ~Student() { std::cout << "Student()" << std::endl; }
};
//只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用
//析构函数，才能形成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
析构函数加virtual，是不是虚函数重写？----是的，因为类的析构函数的名称都被编译器统一处理成为了destuctor，为啥要这样处理呢？---因为要让他们构成重写（覆盖）。那么为什么要让他们构成重写呢？因为下面的场景：
class Person
{
public:
virtual ~Person() { std::cout << "~Person()" << std::endl; }
};
class Student :public Person
{
public:
virtual ~Student()
{
std::cout << "~Student()" << std::endl;
delete[] ptr;
}
protected:
int* ptr = new int[10];
};
int main()
{
Person* p=new Person;
delete p;
p = new Student;
delete p;//p->destructor() + operator delete(p)
//这里我们期望p->destructor()是一个多态调用，而不是普通调用
return 0;
}
所以析构函数可以为虚函数，也需要为虚函数，因为如果用户用动态内存申请空间，派生类对象释放空间时，有需要重写析构函数的需求。
2.4 C++11 override和final
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字字母次序写反而无法构成重载，而这种错误在编译期间是不会报出错的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++提供了override和final两个关键字，可以帮助用户检查是否重写。
1.final：修饰虚函数，表示该虚函数不能再被重写。
class Car
{
public:
virtual void Drive()final {}//加了final修饰虚函数，不能被子类重写
};
class Benz :public Car
{
public:
virtual void Drive() { std::cout << "Benz-舒适" << std::endl; }
};
2.override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car
{
public:
virtual void Drive(){}
};
class Benz:public Car
{
public:
virtual void Drive() override { std::cout << "Benz-舒适" << std::endl; }
};
如何设计一个不能被继承的类？
//方法1：基类构造函数私有化
class A
{
public:
static A CreateObj()
{
return A();
}
private:
A(){}
};
class B:public A
{};
int main()
{
//B b;
return 0;
}
//方法2：基类后面加final修饰
class A final
{
public:
private:
};
class B:public A
{
};
2.5 重载、重写（覆盖）、隐藏（重定义）的对比
3.抽象类
3.1概念
在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承之后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
virtual void Drive()
{
std::cout << "Benz-舒适" << std::endl;
}
};
class BMW :public Car
{
public:
virtual void Drive()
{
std::cout << "BMW-操控" << std::endl;
}
};
void Test()
{
Car* pBenz = new Benz;
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
}
3.2 接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
4.多态的原理
4.1虚函数表
//这里常考一道笔试题，sizeof(Base)是多少？
class Base
{
public:
virtual void Func1()
{
std::cout << "Func1()" << std::endl;
}
private:
int _b = 1;
};
注意：我们这里使用的环境是vs x86平台下，指针大小为4byte。
通过观察测试我们发现b对象时8byte，除了_b成员，还多一个_vfptr放在对象的前面（注意有些平台可能会放在对象的最后面，这个跟平台有关），对象中的这个指针我们叫做虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？我们接着往下分析：
//针对上面的代码我们做出一下改造
//1.我们增加一个派生类Derive去继承Base
//2.Derive中重写Func1
//3.Base再增加一恶搞虚函数Func2和一个普通函数Func3
class Base
{
public:
virtual void Func1()
{
std::cout << "Base::Func1()" << std::endl;
}
virtual void Func2()
{
std::cout << "Base::Func2()" << std::endl;
}
void Func3()
{
std::cout << "Base::Func3()" << std::endl;
}
private:
int _b = 1;
};
class Derive :public Base
{
public:
virtual void Func1()
{
std::cout << "Derive::Func1()" << std::endl;
}
private:
int _d = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}
通过观察和测试，我们发现一下几点问题：
1.派生类对象d中也有一个虚表指针，d对象由两个部分构成，一部分是父类继承下来的成员，虚表指针也就是存在这部分的，另一部分是自己的成员。
2.基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive :: Func1,所以虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法层的叫法，覆盖是原理层的叫法。
3.另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但不是虚函数，所以不会放进虚表。
4.虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
5.总结一下派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中。
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数。
c.派生类自己新增加的虚函数按其在派生类中声明次序增加到到派生类虚表的最后。
6.这里还有一个容易混淆的问题：虚函数存在哪里？虚表存在哪里？答：虚函数存在虚表，虚表存在对象中。注意上面的回答是错的。但是很多人都会这样深以为然。注意：虚表存的是虚函数指针，不是虚函数。虚函数和普通函数一样，都是存放在代码段的，只是它的指针存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪里呢？实际我们去验证一下就会发现vs下是存在代码段的。
注：同一个类型，虚表用的是同一个虚表。
4.2多态的原理
那么究竟多态的原理到底是什么呢？还记得这里Func函数传Person调用的Person::BuyTicket,传Student调用的是Student::ButTicket。
class Person {
public:
virtual void BuyTicket() { std::cout << "买票-全价" << std::endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { std::cout << "买票-半价" << std::endl; }
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person mike;
Func(mike);
Student johnson;
Func(johnson);
return 0;
}
1.观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数时Person::BuyTicket。
2.观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johnson的虚表中找到虚函数时Student::BuyTicket。
3.这样就实现了不同的对象去完成同一行为时，展现出不同的形态。
4.反过来，我们要达到多态，有两个条件，一个是虚函数覆盖，一个就是对象（基类）的指针或引用调用虚函数。
5.在通过下面的汇编代码分析，看出满足多态以后得函数调用，不是在编译时确定的，是运行起来以后到对象中去找的。不满足多态的函数调用是编译时确定好的。
void Func(Person* p)
{
p->BuyTicket();
}
int main()
{
Person mike;
Func(&mike);
mike.BuyTicket();
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
00头1940EC cmp esi, esp
}
int main()
{
...
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
mike.BuyTicket();
00195182 lea ecx, [mike]
00195185 call Person::BuyTicket(01914F6h)
...
}
4.3 动态绑定与静态绑定
1.静态绑定又称为前期绑定（早绑定），在程序编译期间确定了程序的行为，也称为静态多态。比如：函数重载。
2.动态绑定又称为后期绑定（晚绑定），是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
5.单继承和多继承关系的虚函数表
需要注意的是在单继承和多继承关系中，下面我们关注的是派生类对象的虚表模型，因为基类的虚表模型前面我们已经看过了。
5.1 单继承中的虚函数表
class Base
{
public:
virtual void func1() { std::cout << "Base::func1()" << std::endl; }
virtual void func2() { std::cout << "Base::func2()" << std::endl; }
private:
int a;
};
class Derive :public Base
{
public:
virtual void func1() { std::cout << "Derive::func1()" << std::endl; }
virtual void func3() { std::cout << "Derive::func3()" << std::endl; }
virtual void func4() { std::cout << "Derive::func4()" << std::endl; }
private:
int b;
};
观察下图的监视窗口，我们可以发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们可以使用代码打印出虚表中的函数。
5.2 多继承中的虚函数表
class Base1
{
public:
virtual void func1()
{
std::cout << "Base1::func1()" << std::endl;
}
virtual void func2()
{
std::cout << "Base1::func2()" << std::endl;
}
private:
int b1;
};
class Base2
{
public:
virtual void func1()
{
std::cout << "Base2::func1" << std::endl;
}
virtual void func2()
{
std::cout << "Base2::func2" << std::endl;
}
private:
int b2;
};
class Derive :public Base1, public Base2
{
public:
virtual void func1()
{
std::cout << "Derive::func1" << std::endl;
}
virtual void func3()
{
std::cout << "Derive::func3" << std::endl;
}
private:
int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
std::cout << " 虚表地址>" << vTable << std::endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
std::cout << std::endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVTable(vTableb2);
return 0;
}
观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。
5.3菱形继承、菱形虚拟继承
实际中我们不建议设计出菱形继承以及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定的性能损耗。所以菱形继承、菱形虚拟继承的虚表我们在此就不做查看了。
6.继承和多态常见的面试问题
6.1 概念题
1. 下面哪种面向对象的方法可以让你变得富有( A)
A: 继承 B: 封装 C: 多态 D: 抽象
2. (D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关， 而对方法的调用则可以关联于具体的对象。
A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定
3. 面向对象设计中的继承和组合，下面说法错误的是？（C）
A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复 用，也称为白盒复用
B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动 态复用，也称为黑盒复用
C：优先使用继承，而不是组合，是面向对象设计的第二原则
D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封 装性的表现
4. 以下关于纯虚函数的说法,正确的是( A)
A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数
5. 关于虚函数的描述正确的是(B)
A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型
B：内联函数不能是虚函数
C：派生类必须重新定义基类的虚函数
D：虚函数可以是一个static型的函数
6. 关于虚表说法正确的是（ D）
A：一个类只能有一张虚表
B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
C：虚表是在运行期间动态生成的
D：一个类的不同对象共享该类的虚表
7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（D）
A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
B：A类对象和B类对象前4个字节存储的都是虚基表的地址
C：A类对象和B类对象前4个字节存储的虚表地址相同
D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表
8. 下面程序输出结果是什么? （A）
class A{
public:
A(char *s) { cout<
A：class A class B class C class D B：class D class B class C class A
C：class D class C class B class A D：class A class C class B class D
9. 多继承中指针偏移问题？下面说法正确的是( C)
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main(){
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
return 0;
}
A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3
解答：在多继承中，public Base1，public Base2 这个继承关系就是切割顺序。
10. 以下程序输出结果是什么（B）
class A
{
public:
virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
virtual void test() { func(); }
};
class B : public A
{
public:
void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
B* p = new B;
p->test();
return 0;
}
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
解答：1.父类指针。2.虚函数重写。---所以是用父类虚函数的头，加上子类重写虚函数的那部分。
6.2简答题
1.什么是多态？
解答：多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态。多态又分为静态多态和动态多态。静态多态：在程序编译期间确定了程序的行为，也称为静态多态。比如：函数重载。动态多态：是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数（继承中虚函数重写+父类指针调用）。
2.什么是重载、重写（覆盖）、重定义（隐藏）？
解答：重载：是指函数重载，在同一个作用域中，函数名相同，函数参数的类型不同/参数的顺序不同/参数的个数不同，都会引起函数重载。
重写（覆盖）：是指虚函数重写，基类和派生类中都有虚函数，且函数名相同，返回值相同，参数列表也完全相同的前提下，派生类可以对虚函数进行重写。
重定义（隐藏）：是指继承的时候，基类和派生类中，有函数名相同的函数，不构成重写，在派生类中会直接隐藏基类的函数。
3.多态的实现原理？
多态的核心就是利用了虚函数表和虚函数指针，通过虚函数指针间接寻址，运行时进行动态绑定，找到要执行的目标虚函数。
4.inline函数可以是虚函数吗？
可以，不过编译器就会忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。
5.静态成员可以是虚函数吗？
不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式，无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6.构造函数可以是虚函数吗？
不能，因为对象中的虚函数表指针实在构造函数初始化列表阶段才开始初始化的。
7.析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
可以，并且最好把基类的析构函数定义成虚函数。
8.对象访问普通函数快还是虚函数更快？
首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
9.虚函数表是在什么阶段生成的，存在哪里？
虚函数表在编译阶段就生成了，一般情况下存在代码段（常量区）的。
注：继承里的虚基表也存在代码段（常量区）。
10.C++菱形继承的问题？虚继承的原理？
菱形继承会造成数据冗余和二义性。虚继承的原理是通过虚基类表指针（vbptr）和虚基类表实现共享基类的访问，将共享的基类实例放在对象末尾，通过偏移量访问共享的基类。
11.什么是抽象类？抽象类的作用？
包含纯虚函数的类就叫做抽象类（也叫做接口类），抽象类不能实例化出对象。
作用：抽象类规范了派生类必须重写虚函数，另外抽象类也体现出了接口继承关系。
浙公网安备 33010602011771号