目录

• 多态基础
  • 虚函数
    • 虚函数的继承
  • 虚类/虚基类
  • 重写/覆盖
    • 条件:
    • 概念:
  • 多态的条件
    • 其他的多态行为
      • 多态中子类可以不写virtual
      • 协变
        • 代码举例
  • 继承遗留问题解决
    • 析构函数
      • 具体解决方式:
  • 题目1
    • 答案:
    • 解析:
  • 题目2
    • 答案:
  • C++11 override和final
    • final
      • 功能1:禁用继承
        • 使用场景:
      • 功能2:禁用重写
        • 使用场景
    • override
      • 场景:
      • 描述:
      • 用法:
  • 重载、覆盖(重写)、隐藏(重定义)的对比
  • 纯虚函数
    • 概念:
  • 抽象类/纯虚类
    • 概念
    • 特点
  • 接口继承和实现继承
• 多态原理
  • 引入(多态的原理)
  • 虚函数表指针
  • 虚函数表/虚表
    • 描述:
    • 虚表的特性(单继承)
    • 虚表的一般示例:
    • 对象中的虚表指针在构造函数中初始化
    • 虚表的位置
  • 谈谈对象切片
  • 谈谈多态的原理
  • 虚表打印
    • 例程1.VS查看虚表
    • 例程2.程序打印虚表
      • 源码:
  • 多继承虚表
    • 多继承下子类自己新增的虚函数在哪?
      • 多继承虚表打印代码
        • 结论与发现:
        • this指针修正分析
        • 虚表中地址(概念修正)
  • 菱形继承+多态 与 菱形虚拟继承+多态
    • 菱形继承+多态
    • 菱形虚拟继承+多态(子类没有新增虚函数)
    • 菱形虚拟继承+多态（子类自己新增了虚函数）
  • 一些概念
    • 动态绑定和静态绑定
    • 内联函数inline 和 虚函数virtual
    • 静态函数static 与 虚函数
    • 构造函数、拷贝构造函数、赋值运算符重载 与 虚函数
    • 虚函数和普通函数谁快?

多态基础

虚函数

在函数前加上virtual就是虚函数

class A{

public:

virtual void func(){}; //这是一个虚函数

};

虚函数的继承

虚函数的继承体现了接口继承

继承了接口等于继承了函数的壳,这个壳有返回值类型,函数名,参数列表,还包括了缺省参数

只需要重写/覆盖接口的实现(函数体)

虚类/虚基类

含有虚函数的类是虚类.

是虚类,且是基类,则是虚基类

重写/覆盖

条件:

三同:函数名,参数(平常说的参数都是说参数的类型,与缺省参数无关),返回值都要相同

概念:

重写/覆盖是指该函数是虚函数且函数的名字、类型、返回值完全一样的情况下,子类的函数体会替换掉继承下来的父类虚函数的函数体

• 体现接口继承

• 重写/覆盖只有虚函数才有,非虚函数的是隐藏/重定义.注意区别

• 重写/覆盖只对函数体有效,返回值类型,函数名,参数列表,和缺省参数都不能修改

• 只要子类写上满足三同的虚函数都会触发重写.无论是否修改函数体

多态的条件

多态有两个条件,任何一个不满足都不能执行多态 ,分别是

1. 虚函数的重写

多态的基础

class Person {

public:

virtual void BuyTicket() { //是虚函数

std::cout<<"全票"<<std::endl;

}

};

class Student :public Person {

public:

virtual void BuyTicket() { //虚函数的重写

std::cout<<"半票"<<std::endl;

}

};

2. 父类类型的指针或引用(接收父类对象或子类对象)的对象去调用虚函数

   void func(Person& p){ //父类的指针或引用去调用

   p.BuyTicket();

   }

   int main(){

   Person p;

   Student s;

   func(p);

   func(s);

   return 0;

   }

   

其他的多态行为

多态中子类可以不写virtual

多态中子类可以不写virtual,而且只要父类是虚函数,之后继承的子孙类都是虚函数(待验证,是否位于虚表)

class Person {

public:

virtual void BuyTicket() {

std::cout << "全票" << std::endl;

}

};

class Student :public Person {

public:

void BuyTicket() {

std::cout << "半票" << std::endl;

}

};

class Children : public Person {

public:

void BuyTicket(){

std::cout << "三折票" << std::endl;

}

};

void func(Person& p){

p.BuyTicket();

}

int main()

{

Person p;

Student s;

Children c;

func(p);

func(s);

func(c);

return 0;

}

• 说法1:体现接口继承:继承了接口==继承了函数的壳,只需要重写接口的实现(函数体),这样就是体现了接口继承

• 说法2: 可能存在父类子类不是同一个人实现的情况.

  ​ 假设子类必须是虚函数才能实现多态,如果父类是虚函数,而另外一个人写子类时忘记加上virtual,这是就有可能发生内存泄露问题,如切片后再析构的情况(只析构父类,不析构子类).

  ​ 因此,父类是虚函数的情况下,子类不强制需要virtual才能发生多态这种行为,能有一定的安全作用.

缺点:没有统一规范. 最好还是全都加上virtual

协变

概念引入:协变与逆变

协变与逆变规定了编程语言中的类型父子关系的方向

引入这个概念是为了类型安全

---

​协变(父←子)

动物 - 哺乳类 - 熊科 - 黑熊

​逆变(子→父)

---

协变场景下三同中返回值可以不同,且返回值必须是父类或派生类关系的指针或引用

其他方面读者可以阅读更具体的资料

C++协变(covariant)-CSDN博客

代码举例

1. 举例1:父类返回类型为父类,子类返回类型为子类

   class Person {

   public:

   virtual Person& BuyTicket() {

   std::cout << "全票" << std::endl;

   Person p;

   return p;

   }

   };

   class Student :public Person {

   public:

   Student& BuyTicket() {

   std::cout << "半票" << std::endl;

   Student s;

   return s;

   }

   };

   

2. 举例2:父类子类返回类型全部是父类

   class Person {

   public:

   virtual Person& BuyTicket() {

   std::cout << "全票" << std::endl;

   Person p;

   return p;

   }

   };

   class Student :public Person {

   public:

   Person& BuyTicket() {

   std::cout << "半票" << std::endl;

   Person s;

   return s;

   }

   };

   

3. 举例3:返回值类型为非所在类类型

   class A{};

   class B : public A{};

   class Person {

   public:

   virtual A* BuyTicket() {

   std::cout << "全票" << std::endl;

   return nullptr;

   }

   };

   class Student :public Person {

   public:

   B* BuyTicket() {

   std::cout << "半票" << std::endl;

   return nullptr;

   }

   };

   

4. 返回值为非虚函数所在类类型,且都是返回父类

   

注意:

• 反过来,父类中返回值是子类,子类中返回值是父类是不支持的.

• 全部返回子类也不支持

  

• 返回值类型为非所在类类型的情况也是如此

总之,当虚函数返回值为基类类型的指针或引用时,编译器才会检查是否是协变类型.此时如果派生类虚函数返回值是基类或派生类的指针或引用,则判定为协变;否则不是协变

继承遗留问题解决

析构函数

先看继承关系中直接实例对象的代码

class Person {

public:

~Person() { std::cout << "~Person()" << "\n"; }

};

class Student :public Person {

public:

~Student() { std::cout << "~Student()" << "\n"; }

};

int main(){

Person per;

Student stu;

return 0;

}

结果没有问题,析构执行是正确的

再看指针切片样例

int main(){

Person* ptr1 = new Person;

Person* ptr2 = new Student;

delete ptr1;

delete ptr2;

return 0;

}

结果:

显然,没有正确的析构.

• 结果说明对切片后的对象进行析构时,只会执行对应切片类型的析构函数.

在继承篇有提起过的继承体系中析构函数会被重命名成Destructor.

本意:根据指针(引用)指向的对象类型来选择对应的析构函数

结果:根据指针(引用)的类型的来选择对应的析构函数

虽然结果符合正常语法,但是我们在这种情况下并不希望是这样,我们希望它是根据指针(引用)指向的对象类型来选择对应的函数执行.

而根据指针(引用)指向的对象类型来选择对应的函数，这正好就是多态的理念.

因此,为了解决切片中这样的析构函数问题,我们选择将其转化成多态来解决.

此时我们已经满足多态构造的2个条件的其中之一:基类的指针或引用， 剩下的我们需要满足派生类的析构函数构成对基类析构函数的重写。而重写的条件是：返回值类型，函数名，参数列表都相同。对于析构函数，目前还缺的就是函数名相同，因此,析构函数的名称统一处理为destructor.

具体解决方式:

析构函数都成为虚函数

class Person {

public:

virtual ~Person() { std::cout << "~Person()" << "\n"; }

};

class Student :public Person {

public:

virtual ~Student() { std::cout << "~Student()" << "\n"; }

};

int main(){

Person* ptr1 = new Person;

Person* ptr2 = new Student;

delete ptr1;

delete ptr2;

return 0;

}

至此,彻底解决继承体系中析构函数问题.

题目1

1.以下程序输出结果是什么（）

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: 以上都不正确

答案:

解析:

B*p = new B;这里p是普通的指针,不满足多态.

p->test();这里调用了继承下来的test();

test()的实际原型是test(A*this),因此函数体内即为(A*)->func();

因为test()在B中,B会将自己的this传参给test(),即父类类型指针接收子类类型指针.同时func也是虚函数.

因此满足多态,即test()中调用的是子类的func().

又因为虚函数的继承是接口继承,只有函数体是子类的,其他都是父类的,缺省参数也是父类的,因此答案是B->1

题目2

以下程序输出结果是什么（）

class A

{

public:

virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }

};

class B : public A

{

public:

void func(int val = 0) { std::cout << "B->" << val << std::endl; }

virtual void test() { func(); }

};

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: 以上都不正确

答案:

D: B->0

C++11 override和final

final

功能1:禁用继承

C++11中允许将类标记为final，继承该类会导致编译错误.

用法:直接在类名后面使用关键字final

class A final

{};

class B : public A //编译错误

{};

使用场景:

明确该类未来不会被继承时,可以使用final明确告知.

功能2:禁用重写

C++中还允许将函数标记为final，禁用子类中重写该方法

用法:在函数体前使用关键字final

class A {

public:

virtual void func() final {}

};

class B : public A {

public:

void func() {} //编译错误

};

使用场景

一般情况下,只有最终实现的情况下会使用final： 当你在一个派生类中实现了某个虚函数，并且认为这是该函数的“最终”或“最完善”的实现，不希望后续的派生类再次改变其行为。使用final关键字可以确保这一点，防止函数被进一步重写。

对虚函数使用final后,编译器可以做出一些优化，比如内联调用，因为它知道不会有其他版本的函数存在。

override

场景:

C++对函数重写的要求是比较严格的.如果某些情况因为疏忽而导致函数没有进行重写,这种情况在编译期间是不会报错的,只有程序运行时没有得到预期结果才可能意识到出现了问题,等到这时再debug已经得不偿失了.

因此,C++11提供了override关键字,可以帮助用户检测是否完成重写

描述:

override(覆盖)关键字用于检查派生类虚函数是否重写了基类的某个虚函数，如果没有则无法通过编译。

用法:

在需要进行重写的虚函数的函数体前或参数列表花括号后加上override

class A {

public:

virtual void func() {}

};

class B : public A {

public:

void func(int i) override{ }

};

重载、覆盖(重写)、隐藏(重定义)的对比

纯虚函数

概念:

在虚函数后面写上=0,这个函数就为纯虚函数.

virtual void fun() = 0;

纯虚函数只能写声明,不能写函数体.

抽象类/纯虚类

概念

含有纯虚函数的类是纯虚类,更多的是叫抽象类(也叫做接口类)

class A{

virtual void func() = 0;

};

特点

• 抽象类不能实例化对象

• 抽象类的派生类如果不重写纯虚函数,则还是抽象类

• 纯虚函数规范了派生类必须重写,更体现接口继承

• 纯虚类可以有成员变量

接口继承和实现继承

从类中继承的函数包含两部分：一是"接口"(interface)，二是 "实现" (implementation).

• 接口就是函数的"壳",是函数除了函数体外的所有组成.

• 实现就是函数的函数体.

纯虚函数 => 继承的是:接口 (interface)

普通虚函数 => 继承的是:接口 + 缺省实现 (default implementation)

非虚成员函数 => 继承的是:接口 + 强制实现 (mandatory implementation)

• 普通函数的继承是一种实现继承，派生类继承了基类函数，继承的是函数的实现,目的是为了复用函数实现.

• 普通虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口+缺省实现，目的是为了重写，达成多态.

• 纯虚函数只继承了接口,要求用户必须要重写函数的实现.

如果不实现多态，不要把函数定义成虚函数。

多态原理

引入(多态的原理)

计算下面虚类的大小

class Base{

public:

virtual void func() {}

private:

int _a;

char _b;

};

int main(int argc, char* argv[])

{

std::cout<<sizeof(Base)<<"\n";

return 0;

}

结果:

如果是一般的类,那我们会认为是计算结构体对齐之后的大小,结果应当是8.

但计算结果发现,虚类的结果是12,说明虚类比普通类多了一些东西.

实例化对象Base b;查看监视窗口

可以发现对象的头部多了一个指针_vfptr;这个指针叫做虚函数表指针,它指向了虚函数表

虚函数表指针

指向虚表的指针,叫虚函数表指针,位于对象的头部.

定义:

​ 如果在类中定义了虚函数,则对象中会增加一个隐藏的指针,叫虚函数表指针__vfptr,虚函数表指针在成员的前面,直接占了4/8字节.

虚函数表/虚表

描述:

虚函数表指针所指向的表,叫做虚函数表(virtual function table),也叫做虚表

虚函数表本质是一个虚函数指针数组.元素顺序取决于虚函数的声明顺序.大小由虚函数的数量决定.

虚表的特性(单继承)

• 虚表在编译期间生成.

  虚表是由虚函数的地址组成,而编译期间虚函数的地址已经存在,因此能够在编译期间完成.

• 虚函数继承体系中,虚基类先生成一份虚表,之后派生类自己的虚表都是基于从父类继承下来的虚表.

• 特例,为了方便使用,VS在虚表数组最后面放了一个nullptr.(其他编译器不一定有)

• 子类会继承父类的虚函数表(开辟一个新的数组,浅拷贝)
• 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数,如果子类没有重写,则虚函数表和父类的虚函数表的元素完全一样
• 派生类自己新增加的虚函数,从继承的虚表的最后一个元素开始,按其在派生类中的声明次序增加到派生类虚表的最后。
• 派生类自己新增的虚函数放在继承的虚表的后面,如果是基类则是按顺序从头开始放,总而言之,自己新增的虚函数位置一定比继承的虚函数位置后
• 虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中.另外对象中存的不是虚表,存的是虚表指针
• 虚表是在编译阶段就完成了,在初始化列表完成的是虚表指针的初始化
• 同一类型直接定义的对象共享同一个虚表
• 子类对象直接赋值给父类对象后就变成了父类对象,只拷贝成员,不拷贝虚表,虚表还是父类的

虚表的一般示例:

class Person {

public:

virtual void BuyTicket(int val = 1) {

std::cout << "全票" << ":" << val << "\n";

}

virtual void func(int val = 1) {

std::cout << "全票" << ":" << val << "\n";

}

};

class Student :public Person {

public:

void BuyTicket(int val = 0) { //覆盖

std::cout << "半票" << "=" << val << "\n";

}

};

int main() {

Person p;

Student s;

return 0;

}

对象中的虚表指针在构造函数中初始化

注:虚表指针和成员谁先初始化由编译器决定

虚表的位置

虚表没有明确说必须在哪里,不过我们可以尝试对比各个区的地址,看虚表的大致位置

class Base{

public:

virtual void func(){

}

private:

int _a;

};

class Derive :public Base {

};

int main()

{

Base b;

Derive d;

int x = 0;

int *y = new int;

static int z = 1;

const char * str = "hello world";

printf("栈对象地址: %p\n",&x);

printf("堆对象地址: %p\n",y);

printf("静态区对象地址: %p\n",&z);

printf("常量区对象地址: %p\n",str);

printf("Base对象虚表指针: %p\n",*(int**)(&b)); //32位环境

printf("Derive对象虚表指针:%p\n",*(int**)(&d));

return 0;

}

根据地址分析,虚表指针与常量区对象地址距离最近,因此可以推测虚表位于常量区.

另外,在监视窗口中观察虚表指针与虚函数地址也可以发现,虚表指针与虚函数地址也是比较接近,也可以大致推测在代码段中.(代码段常量区很贴近,比较ambiguous,模棱两可的)

从应用角度来说,虚表也应当位于常量区中,因为虚表在编译期间确定好后,不会再发生改变,在常量区也是比较合适的.

谈谈对象切片

我们可以使用子类对象给父类类型赋值,但要注意C++中不支持通过对象切片实现多态.

首先赋值过程会涉及大量拷贝.成本开销比较大.

其次,拷贝只拷贝成员,不会拷贝虚表.

因为子类中继承的自父类的虚表可能被子类覆盖过,如果切片给父类对象,那么父类对象的虚表中就会有子类重写的虚函数,显然不合理.

谈谈多态的原理

多态是怎么实现的,其实程序也不知道自己调用的是子类还是父类的,在它眼里都是一样的父类指针或引用.

如果是虚函数,则在调用时,会进入到"父类"中去,找到虚函数表中的函数去调用,是父类的就调用父类的,是子类就调用子类的.如果不是虚函数,则直接调用.

多态的实际原理也是传什么调什么,编译期间虚函数表已经确定好了

再看多态的两个条件

• 为什么需要虚函数重写,虚表中存的就是子类的虚函数,重写后就和父类不同了,也就能实现多态的效果.

• 为什么需要父类的指针或引用,就是因为指针或引用既能指向父类也能指向子类,能够实现切片,区分父类和子类

虚函数覆盖这个词的由来就是,子类重写的虚函数会覆盖父类的.

覆盖是原理层的叫法.重写是语法的叫法

虚表打印

例程1.VS查看虚表

class Person {

public:

virtual void BuyTicket(int val = 1) {

std::cout << "全票" << ":" << val << "\n";

}

virtual void func(int val = 1) {

std::cout << "全票" << ":" << val << "\n";

}

};

class Student :public Person {

public:

void BuyTicket(int val = 0) {

std::cout << "半票" << "=" << val << "\n";

}

virtual void Add()

{

std::cout<<"Studetn"<<"\n";

}

};

class C : public Student {

public:

virtual void Add()

{

std::cout<<"C"<<"\n";

}

int _c = 3;

};

void fun(Student &s){

s.Add();

}

int main() {

Person p;

Student s;

C c;

fun(c);

return 0;

}

对上例函数查看VS监视时,发现虚表不显示完全

需要在监视窗口中手动输入(void**)0x虚函数表指针,10,表示以(void*)[10]方式展开

此后就能全部显示虚表了

例程2.程序打印虚表

源码:

(仅适用VS,因为VS会将虚表末尾置空,如果是g++,则需要明确虚表有几个虚函数)

class A {

public:

virtual void fun1(){

std::cout<<"func1()"<<"\n";

}

virtual void fun2(){

std::cout<<"func2()"<<"\n";

}

};

class B :public A {

public:

virtual void fun3(){

std::cout<<"func3()"<<"\n";

}

};

using VFPTR = void(*)(void);

void PrintVFTable(VFPTR table[])

{

for (int i = 0; table[i]; i++)

{

//1.打印虚类对象的虚表

printf("%p",table[i]);

//2.指针不够直观的情况下.可以执行函数指针得到更具象的结果

VFPTR f = table[i];

f();

//小细节:f()能够正常执行,说明这样的调用方式能够自动将虚表所在对象的this传参到虚函数中.

}

}

int main()

{

A a;

B b;

PrintVFTable((VFPTR*)(*((VFPTR*)&a))); //方式1 (修改,VFPTR*比int*更通用)

puts("");

PrintVFTable(*(VFPTR**)&b); //方式2 ,在明确指向逻辑的情况下,二级指针更为简洁

/* 代码理解:

1.typedef和using语法层面功能都是将类型重命名,这个重命名会被认定成一个新类型,需要时再进行解释.

2.int*在32位和64位下解引用都是4字节.而指针大小在32位下是4字节,64位下是8字节.在64位机器下使用int*解引用的话,就会得到错误的结果.因此int*不够普遍.

3.VFPTR被当作一个新类型来看待.直接使用VFPTR时,编译器认为是非指针变量;使用VFPTR*时,编译器认为是一级指针变量.(VFPTR*)&a即为将a的地址转成类型为VFPTR的一级指针.之后,解引用则以VFPTR的大小为步长,取出相应的数据(虚表指针,也是虚表首地址).VFPTR实际类型为函数指针,32位下为4字节,64位下为8字节,因此解引用后能够取得正确的结果.

*/

return 0;

}

模型图

多继承虚表

先看虚函数多继承体系下内存布局

class Base1 {

public:

virtual void func1() { std::cout << "Base1::func1" <<std::endl; }

virtual void func2() { std::cout << "Base1::func2" << std::endl; }

private:

int b1 = 1;

};

class Base2 {

public:

virtual void func1() { std::cout << "Base2::func1" << std::endl; }

virtual void func2() { std::cout << "Base2::func2" << std::endl; }

private:

int b2 = 1;

};

class Derive : public Base1, public Base2 {

public:

//子类重写func1

virtual void func1() { std::cout << "Derive::func1" << std::endl; }

//子类新增func3

virtual void func3() { std::cout << "Derive::func3" << std::endl; }

private:

int d1 =2;

};

int main()

{

Derive d;

return 0;

}

简单分析可知,虚函数多继承体系下派生类会根据声明顺序依次继承父类.继承方式类似于虚继承.

多继承下子类自己新增的虚函数在哪?

我们知道,单继承中,子类自己新增的虚函数会尾插到虚表的末尾.

那么多继承呢?是每个父类都添加?还是只添加到其中一个?添加到一个的话添加到哪里?

要知道结果,必须要看一眼虚表的真实情况.因此我们打印所有虚表看看情况.

多继承虚表打印代码

int main()

{

Derive d;

/*打印d中Base1的虚表*/

std::cout<<"Base1的虚表"<<"\n";

PrintVFTable(*(VFPTR**)(&d));

puts("");

/*打印d中Base2的虚表*/

std::cout<<"Base2的虚表"<<"\n";

//方法1,手动计算指针偏移

//PrintVFTable((VFPTR*)*(VFPTR*)((char*)&d+sizeof(Base1)));

//PrintVFTable(*(VFPTR**)((char*)&d+sizeof(Base1)));

//方法2,切片,自动计算指针偏移 -- 推荐,不容易出错

Base2 *b2 = &d;

PrintVFTable(*(VFPTR**)b2);

return 0;

}

结论与发现:

• 通过结果能证明,子类自己新增的虚函数只会添加进第一个继承的父类的虚表中,也就是尾插.
• 子类会继承所有父类的虚表,有多少个父类就有多少个虚表

• 结果也证明,子类重写会对所有父类的同名函数进行覆盖

• 观察结果还发现,两个func1的地址居然不一样.这其实涉及到C++this指针的原理问题->this指针修正.

要搞明白是什么情况,我们需要观察汇编代码,去看更深层次的逻辑.

this指针修正分析

例程代码

int main(){

Derive d;

Base1 *ptr1 = &d;

Base2 *ptr2 = &d;

ptr1->func1();

ptr2->func1();

return 0;

}

先观察ptr1

再看ptr2

对比可以发现,ptr2要比ptr1走多了好几步才能正确调用fun1.

解释:

看ptr2的的中间过程有句汇编sub ecx,8,功能是ecx-8再放到ecx中.而ecx在类中通常表示类的this指针,即sub ecx,8得功能是将this指针-8,这里8刚好是sizeof(Base1)的值,因此sub ecx,8就可以解释成this向下偏移8个字节,因为对象的this指针位于低字节,这就同时刚好满足了this指向Base2.再结合问题场景,就可以同步证明ptr2多走的这几步目的就是为了让指针正确偏移回对象d的this.

再结合切片原理,切片后会自动计算将ptr2指向了d中Base2的首地址,可以推测切片后ecx也指向了Base2的首地址.为了能够发生多态,需要将ecx重新偏移至正确位置.

这就是多继承下多态的原理

虚表中地址(概念修正)

1. 虚函数地址：这是虚函数在程序内存中的实际地址，即函数体开始的位置。
2. 虚表中的地址：虚表中存储的地址通常直接指向虚函数的实际地址。然而，在某些情况下，如为了实现一些优化，编译器可能不会直接在虚表中存储虚函数的地址，而是存储一个“跳跃”函数的地址，这个跳跃函数再跳转到虚函数的真实地址。这种跳跃函数可以用来做额外的检查或者优化，例如性能计数、调试信息插入等。

所以，虚表中存放的地址大多数情况下就是虚函数的真实地址，但在某些特定的优化场景下，它可能指向一个中间函数，这个中间函数再负责跳转到真实的函数地址。这种间接调用的机制有时被称为“thunk”，它允许编译器在运行时进行更复杂的控制流分析和优化。

对于现代的C++编译器，如GCC或Clang，它们默认的行为是在虚表中直接存储虚函数的真实地址，除非有特殊的优化需求。如果想了解具体的实现，可以通过反汇编工具（如objdump, IDA Pro等）查看编译后的二进制文件，检查虚表的结构和内容。

菱形继承+多态 与 菱形虚拟继承+多态

菱形继承本来就是很复杂的东西,再加上多态,更加复杂,实际工作中也很少会使用菱形继承多态.

简单演示一下,有兴趣的读者可以自行扩展研究.

菱形继承+多态

class A {

public:

virtual void func1() {}

public:

int _a;

};

class B : public A {

public:

virtual void func1() {}

public:

int _b;

};

class C : public A {

public:

virtual void func1() {}

public:

int _c;

};

class D : public B, public C {

public:

virtual void func1() {}

public:

int _d;

};

int main() {

D d;

d.B::_a = 1;

d.C::_a = 2;

d._b = 3;

d._c = 4;

d._d = 5;

return 0;

}

内存布局:

菱形虚拟继承+多态(子类没有新增虚函数)

class A {

public:

virtual void func1() {}

public:

int _a;

};

class B : virtual public A {

public:

virtual void func1() {}

//virtual void func2() {}

public:

int _b;

};

class C : virtual public A {

public:

virtual void func1() {}

//virtual void func3() {}

public:

int _c;

};

class D : public B, public C {

public:

virtual void func1() {}

public:

int _d;

};

(其中要求最远类必须重写虚基类A的虚函数,因为要消除二义性,是B是C都不好,最好是D.)

内存布局:

和非多态菱形虚拟继承很类似.只重写虚基类虚函数时,只有虚基类有虚表

菱形虚拟继承+多态（子类自己新增了虚函数）

class A {

public:

virtual void func1() {}

public:

int _a;

};

class B : virtual public A {

public:

virtual void func1() {}

virtual void func2() {}

public:

int _b;

};

class C : virtual public A {

public:

virtual void func1() {}

virtual void func3() {}

public:

int _c;

};

class D : public B, public C {

public:

virtual void func1() {}

public:

int _d;

};

内存布局:

64位环境下内存布局

推测虚基表中低四字节是存放虚表偏移量,也可能是到B或C类型首部的偏移量.

一些概念

动态绑定和静态绑定

• 静态绑定又称为前期绑定(早绑定),在程序编译期间就确定了程序的行为,即编译时,也称为静态多态.

  静态多态例子:函数重载,如std::cout<<的类型自动识别,原理就是函数名修饰规则将operator<<(不同的参数)在编译时生成多份(都是生成多份,C语言需要程序员手动,C++由编译器自动生成),使传的参数不同时能够对外表现出不同的行为.这种技术给开发者和用户都带来了使用上的便利.

• 动态绑定也称为后期绑定(晚绑定),是在程序运行期间,即运行时,根据具体拿到的类型确定程序的具体行为,调用具体的函数,也称为动态多态.虚函数多态就是动态多态.

内联函数inline 和 虚函数virtual

inline如果被编译器识别成内联函数,则该函数是没有地址的. 与虚表中存放虚函数的地址有冲突.

但事实上,inline 和 virtual 可以一起使用 :

• 这取决于使用该函数的场景:内联是一个建议性关键字,如果发生多态,则编译器会忽略内联.如果没有发生多态,才有可能成为内联函数

• 即:多态和内联可以一起使用,但同时只能有一个发生

静态函数static 与 虚函数

静态成员函数不能是虚函数,因为静态成员函数没有this指针,与多态发生条件矛盾

1. 父类引用/指针去调用

2. static函数没有隐藏this参数.不满足虚函数重写条件"三同"

3. 静态成员函数目的是给所有对象共享,不是为了实现多态

构造函数、拷贝构造函数、赋值运算符重载 与 虚函数

• 构造,拷贝构造不能是虚函数

  1. 构造函数需要帮助父类完成初始化,必须一起完成,不能像多态那样非父即子(父对象调父的,子对象调子的);
  2. 虚表指针初始化是在构造函数的初始化列表中完成的,要先执行完构造函数,才能有虚函数
  3. 构造函数多态没有意义

• 赋值运算符重载也和拷贝构造一样,不建议写成虚函数,虽然编译器不报错.

虚函数和普通函数谁快?

一般来说,普通函数会比构成多态调用的虚函数快.但要注意,是虚函数在构成多态调用的情况下.

看例子1:

class AA {

public:

virtual void func1() {}

};

class BB : public AA {

void func2(){};

};

int main() {

AA a;

BB b;

a.func1();

b.func1();

return 0;

}

在VS2019-32位环境下,两种函数在对象的调用下汇编代码是一样的.因此这种情况下它们一样快.

看例子2:

成员函数为非虚函数时,指针调用是普通调用

class AA {

public:

void func1() {}

};

class BB : public AA {

};

int main()

{

BB b;

BB*ba = &b;

pb->func1();

return 0;

}

看例子3:

class AA {

public:

virtual void func1() {}

};

class BB : public AA {

};

int main()

{

AA*pa = &a;

pa->func1();

BB*pb = &b;

pa->func1();

return 0;

}

在虚函数情况下(包括继承和非继承),使用指针调用都会触发多态的调用方式,显然这时调用虚函数效率会比普通函数慢.

小结:

通过上面几个例子分析,发现有虚函数,且是指针的情况下,无论有没有发生多态,调用方式都会发生改变.上面举的名词"多态的调用方式"是为了描述这种调用方式.

这种调用方式简化了编译器的调用逻辑:只要是虚函数,且是指针/引用,都会去虚表中找.如果满足多态的条件就能发生多态的现象,否则就是正常调用.

因此,需要注意区分多态的调用方式与多态的现象.常说的多态的两个条件是指满足这两个条件才能触发多态的现象.与是否是多态的调用方式无关.