[请回答C++] 多态&&虚函数&&重写&&抽象类&&虚表&&动态绑定

多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

一般的就是调用不同的函数，展现出多种形态

就像宝可梦伊布，进化的时候可以由多种形态，具体看是哪一个子类

多态的条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。

那么在继承中要构成多态还有两个条件：

1. 父类必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且子类必须对父类的虚函数进行重写

虚函数

class Eevee
{
public:
	//被virtual修饰的类成员函数
	virtual void Evolution()
	{
		cout << "伊布->" << endl;
	}
};

需要注意的是：

🌴 只有类的非静态成员函数前可以加virtual，普通函数前不能加virtual。

🌴 虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

虚函数的重写

虚函数的重写也叫做虚函数的覆盖，若父类中有一个和子类完全相同的虚函数(返回值类型相同、函数名相同以及参数列表完全相同)，此时我们称该父类的虚函数重写了子类的虚函数。其实重写就是隐藏的一个特殊情况

//父类
class Eevee
{
public:
	//被virtual修饰的类成员函数
	virtual void Evolution()
	{
		cout << "伊布->" << endl;
	}
};
//子类
class Umbreon : public Eevee
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void Evolution()
	{
		cout << "伊布->夜精灵" << endl;
	}
};
//子类
class Leafeon : public Eevee
{
public:
	//子类的虚函数重写了父类的虚函数
virtual void Evolution()
	{
		cout << "伊布->叶伊布" << endl;
	}
};

现在我们就可以通过父类Person的指针或者引用调用虚函数BuyTicket，此时不同类型的对象，调用的就是不同的函数，产生的也是不同的结果，进而实现了函数调用的多种形态。

void Func(Eevee& p)
{
	//通过父类的引用调用虚函数
	p.Evolution();
}
void Func(Eevee* p)
{
	//通过父类的指针调用虚函数
	p->Evolution();
}

注意： 在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，主要原因是因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数属性。但是这种写法不是很规范，因此建议在派生类的虚函数前也加上virtual关键字。

多态效果

调用的函数和对象有关，指向哪个对象调用谁的虚函数

多态例外

1. 协变
2. 析构函数（为什么析构函数建议定义虚函数）
3. 子类中重写的虚函数可以不加virtual（最好还是加上）

协变

协变（基类与派生类虚函数的返回值类型不同）

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用，称为协变。

//基类
class A
{};
//子类
class B : public A
{};
//基类
class Person
{
    public:
    //返回基类A的指针
    virtual A* func()
    {
        cout << "A* Person::f()" << endl;
        return new A;
    }
};
//子类
class Student : public Person
{
    public:
    //返回子类B的指针
    virtual B* func()
    {
        cout << "B* Student::f()" << endl;
        return new B;
    }
};

基类Person当中的虚函数fun的返回值类型是基类A对象的指针，派生类Student当中的虚函数fun的返回值类型是派生类B对象的指针，此时也认为派生类Student的虚函数重写了基类Person的虚函数。

int main()
{
	Person p;
	Student stu;
	//父类指针指向父类对象
	Person* ptr1 = &p;
	//父类指针指向子类对象
	Person* ptr2 = &stu;
	//父类指针ptr1指向的p是父类对象，调用父类的虚函数
	ptr1->func(); //A* Person::f()
	//父类指针ptr2指向的st是子类对象，调用子类的虚函数
	ptr2->func(); //B* Student::f()
	return 0;
}

析构函数的重写

（基类与派生类析构函数的名字不同）

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。

为什么我们要这么设计？

分别new一个父类对象和子类对象，并均用父类指针指向它们，然后分别用delete调用析构函数并释放对象空间。

int main()
{
	//分别new一个父类对象和子类对象，并均用父类指针指向它们
	Person* p1 = new Person;
	Person* p2 = new Student;

	//使用delete调用析构函数并释放对象空间
	delete p1;
	delete p2;
	return 0;
}

在这种场景下，若是父类和子类的析构函数没有构成重写就可能会导致内存泄漏，因为此时delete p1和delete p2都是调用的父类的析构函数，而我们所期望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们期望的是一种多态行为。

此时只有父类和子类的析构函数构成了重写，才能使得delete按照我们的预期进行析构函数的调用，才能实现多态。因此，为了避免出现这种情况，比较建议将父类的析构函数定义为虚函数。

补充：在继承当中，子类和的析构函数和父类的析构函数构成隐藏的原因就在这里，这里表面上看子类的析构函数和父类的析构函数的函数名不同，但是为了构成重写，编译后析构函数的名字会被统一处理成destructor();。

C++11 提供关键字

C++对函数重写的要求比较严格，有些情况下由于疏忽可能会导致函数名的字母次序写反而无法构成重写，而这种错误在编译期间是不会报错的，直到在程序运行时没有得到预期结果再来进行调试会得不偿失，因此，C++11提供了final和override两个关键字，可以帮助用户检测是否重写。

以上的检测和const差不多，主要是为了规范和提醒

final：修饰虚函数，表示该虚函数不能再被重写。

class Eevee
{
public:
	//被virtual修饰的类成员函数
	virtual void Evolution() final
	{
		cout << "伊布->" << endl;
	}
};

override：检查派生类虚函数是否重写了基类的某个虚函数，如果没有重写则编译报错。

class Eevee
{
public:
	//被virtual修饰的类成员函数
	virtual void Evolution() override
	{
		cout << "伊布->" << endl;
	}
};

三个概念的对比

抽象类

抽象类快速入门

在虚函数的后面写上 = 0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯 虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

抽象类注意事项

1. 抽象类必须重写
2. 抽象类 – 不能实例化出对象

接口的意义

1、可以更好的去表示现实世界中，没有实例对象对应的抽象类型 比如：植物、人、动物
2、体现接口继承，强制子类去重写虚函数(不重写，子类也是抽象类)

要注意跟override区分，override检查子类虚函数是否完成重写。

接口继承和实现继承

普通函数的继承是实现继承

一般的子类继承父类，可以使用父类的函数，继承的是函数的实现

接口函数的实现是接口继承

虚函数的继承是一种接口继承，子类继承了父类的接口，目的是为了重写，然后实现多态

因此如果我们的目的不是为了实现多态，那么最好不要把函数定义成虚函数

一般那些现实社会中都没有严格定义的比较抽象的类就可以定义为抽象类，比如植物，动物，Pokemon等等，这些类不需要实例化，但是可以去继承然后实现

class Pokemon //抽象类
{
public:
	// 纯虚函数
	virtual void Move1()=0;
	virtual void Move2() = 0;
	virtual void Move3() = 0;
	virtual void Move4() = 0;
protected:
	string _Type1;
	string _Type2;
	string _Abilities;
};

//妙蛙花
class Venusaur :public Pokemon
{
public:
	virtual void Move1()
	{
		cout << "Solar Beam" << endl;
	}
	virtual void Move2() 
	{
		cout << "Poison Powder" << endl;
	}
	virtual void Move3() 
	{
		cout << "Sleep Powder" << endl;
	}
	virtual void Move4() 
	{
		cout << "Venoshock" << endl;
	}
protected:
	string _Abilities ="Overgrow";
	string _Type1 ="Grass";
	string _Type2="Poison";
};

//喷火龙
class Charizard :public Pokemon
{
public:
	virtual void Move1()
	{
		cout << "Flamethrower" << endl;
	}
	virtual void Move2() 
	{
		cout << "Flare Blitz" << endl;
	}
	virtual void Move3() 
	{
		cout << "Air Slash" << endl;
	}
	virtual void Move4() 
	{
		cout << "Dragon Dance" << endl;
	}
protected:
	string _Abilities = "Blaze";
	string _Type1 = "Fire";
	string _Type2 = "Flying";
};

多态的原理

Intro

这里常考一道笔试题：sizeof(Base)是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
    char _ch='\0';
};

调试可以发现其实Base中不是8个字节，其中还隐藏着一个虚表指针

虚表指针就是为了实现多态的，实际上他是一个指针数组，指针指向的就是虚函数

b对象当中除了成员变量外，实际上还有一个_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）。

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

这里和菱形继承是不一样的虽然都是用了virtual关键字，但是使用场景完全不一样，解决的也是不一样的问题，互相没有关联，虚继承产生的是虚基表，虚基表中村的是距离虚基类的偏移量

虚函数表

存在一个虚函数表

如果子类有对父类的虚函数完成重写，那么子类的虚表指针就会指向子类重写的虚函数，如果没有那个子类的虚表指针就会指向父类的虚函数

// 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;
}

通过调试可以发现，父类对象b和基类对象d当中除了自己的成员变量之外，父类和子类对象都有一个虚表指针，分别指向属于自己的虚表。

实际上虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。

而子类虽然继承了父类的虚函数Func1和Func2，但是子类对父类的虚函数Func1进行了重写，因此，子类对象d的虚表当中存储的是父类的虚函数Func2的地址和重写的Func1的地址。这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地址的覆盖，重写是语法的叫法，覆盖是原理层的叫法。

其次需要注意的是：Func2是虚函数，所以继承下来后放进了子类的虚表，而Func3是普通成员函数，继承下来后不会放进子类的虚表。此外，虚函数表本质是一个存虚函数指针的指针数组，一般情况下会在这个数组最后放一个nullptr。

小结一下虚函数表的执行：

1. 先将基类中的虚表内容拷贝一份到派生类的虚表。
2. 如果派生类重写了基类中的某个虚函数，则用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。
3. 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚函数表三问

🥝 虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

虚表实际上是在构造函数初始化列表阶段进行初始化的

注意虚表当中存的是虚函数的地址不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的地址又存到了虚表当中。另外，对象中存的不是虚表而是指向虚表的指针。

至于虚表是存在哪里的，我们可以通过以下这段代码进行判断。

想办法写一段程序论证虚表存放在哪里

打印一下虚表的地址，看一下前四个字节的值，就是虚表的地址

int main()
{
	// 取虚表地址打印一下
	Base b;
	Base* p = &b;
	printf("vftptr:%p\n", *((int*)p));

	int i;
	printf("栈上地址:%p\n", &i);
	printf("数据段地址:%p\n", &j);

	int* k = new int;
	printf("堆地址:%p\n", k);
	const char* cp = "hello world";
	printf("代码段地址:%p\n", cp);

	return 0;
}

分别在常量区，堆，栈，数据段，创建一个变量来看看哪一个更接近

说明VS很可能放在了代码段

虚函数表和多态

#include <iostream>
using namespace std;
//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
	int _p = 1;
};
//子类
class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
	int _s = 2;
};
int main()
{
	Person Mike;
	Student Johnson;
	Johnson._p = 3; //以便观察是否完成切片
	Person* p1 = &Mike;
	Person* p2 = &Johnson;
	p1->BuyTicket(); //买票-全价
	p2->BuyTicket(); //买票-半价
	return 0;
}

理解一下上图和多态的原理实现

1. 父类指针p1指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
2. 父类指针p2指向Johnson对象，p2>BuyTicket在Johnson的虚表中找到的虚函数就Student::BuyTicket。

思考多态的实现要求和多态的实现原理

多态构成的两个条件，一是完成虚函数的重写，二是必须使用父类的指针或者引用去调用虚函数。必须完成虚函数的重写是因为我们需要完成子类虚表当中虚函数地址的覆盖，那为什么必须使用父类的指针或者引用去调用虚函数呢？为什么使用父类对象去调用虚函数达不到多态的效果呢？

Person* p1 = &Mike;
Person* p2 = &Johnson;

使用父类指针或者引用时，实际上是一种切片行为，切片时只会让父类指针或者引用得到父类对象或子类对象中切出来的那一部分。

因此，我们用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是不一样的，最终调用的函数也是不一样的。

Person p1 = Mike;
Person p2 = Johnson;

使用父类对象时，切片得到部分成员变量后，会调用父类的拷贝构造函数对那部分成员变量进行拷贝构造，而拷贝构造出来的父类对象p1和p2当中的虚表指针指向的都是父类对象的虚表。因为同类型的对象共享一张虚表，他们的虚表指针指向的虚表是一样的。

因此p1和p2通过虚表指针找到的虚表是一样的，最终调用的函数也是一样的，也就无法构成多态。

小结：

1. 构成多态，指向谁就调用谁的虚函数，跟对象有关。
2. 不构成多态，对象类型是什么就调用谁的虚函数，跟类型有关。

动态绑定与静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数
   重载

2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用
   具体的函数，也称为动态多态。

反汇编看一下编译器调用过程

构成多态，指向谁调用谁的虚函数，跟对象有关，运行值到指向的对象的虚表中找到要调用的虚函数

不构成多态，对象类型是什么，调用的就是哪个函数，和类型有关，编译器直接调用函数地址

这样就很好的体现了静态绑定是在编译时确定的，而动态绑定是在运行时确定的。

指针或者引用，调用虚函数时，不是编译时确定的，是运行时到指向的对象中的虚表中去找对应虚函数调用，所以指向的父类对象，调用就是父类的虚函数，指向的时子类的对象，调用的就是子类的虚函数

1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是
   Person::BuyTicket。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数
   是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

常见概念理解

🍁 对象中的虚表指针是在什么阶段初始化的？虚表是什么时候生成的？

​ 构造函数初始化列表 编译时生成

🍁 虚函数放到虚表里面，这句话对吗？

这句话不准确，虚表里面放的是虚函数地址，虚函数跟普通函数一样，编译完成后都是放在代码段

🍁 一个类中所有的虚函数地址都会放到虚表中

子类相当于是把父类的虚表拷过来，然后重写自己的，然后父的那部分不动，相当于拷贝过来以后进行覆盖

🍁 虚函数的重写也叫做虚函数的覆盖

语法层概念 实现层概念

单继承系函数表

调试时监视窗口是看不到子类中没有重写的虚函数的

这是VS窗口的特性，可能是优化掉的

那么其实可以写一个程序打印一下虚表

// 写一个程序打印一下虚表，确认虚表中调用的函数
typedef void(*VFunc)();//定义一个函数指针
void PrintVFT(VFunc* ptr)   // 存函数指针的数组指针
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; ++i)
	{
		printf("VFT[%d]:%p->", i, ptr[i]);
		ptr[i]();
	}
	printf("\n");
}
int main()
{
	Base b;
	PrintVFT((VFunc*)(*(int*)&b));//先把地址转成int*取前4个字节，然后解引用地址强转成VFunc*
	Derive d;
	PrintVFT((VFunc*)(*(int*)&d));
	return 0;
}

思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr

1. 先取b的地址，强转成一个int*的指针
2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
4. 虚表指针传递给PrintVTable进行打印虚表
5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。

多继承的虚表

虚函数是两个父类都重写的

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(*VFunc)();
void PrintVFT(VFunc* ptr)   // 存函数指针的数组指针
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; ++i)
	{
		printf("VFT[%d]:%p->", i, ptr[i]);
		ptr[i]();
	}
	printf("\n");
}

int main()
{
	Base1 b1;
	Base2 b2;
	Derive d;
	PrintVFT((VFunc*)(*(int*)&d));
	PrintVFT((VFunc*)(*(int*)((char*)&d + sizeof(Base1))));
	return 0;
}

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

菱形继承

菱形虚继承不常用，也不是一个好的结构

class A
{
public:
	virtual void func()
	{
		cout << "A::func()" << endl;
	}
public:
	int _a;
};

// class B : public A
class B : virtual public A
{
public:
	virtual void func()
	{
		cout << "B:func()" << endl;
	}

	virtual void func1()
	{
		cout << "B:func1()" << endl;
	}
public:
	int _b;
};

// class C : public A
class C : virtual public A
{
public:
	virtual void func()
	{
		cout << "C::func()" << endl;
	}

	virtual void func1()
	{
		cout << "C::func1()" << endl;
	}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void func()
	{
		cout << "D::func()" << endl;
	}

	virtual void func1()
	{
		cout << "D::func1()" << endl;
	}
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;
}

下面用内存画图直观看一下菱形继承的状态，非常复杂，而且也用不到

上面的图是放开了func1，下面的图是把func1注释掉了的结果

也就是上图是有重写的func，B和C自己也有一个单独的虚函数，下图的是只有重写的函数func

由于B和C单独的虚函数不属于A所以不能放在A中，只能建立自己单独的虚表

格物致知

下面的程序输出是什么(菱形继承)

#include<iostream>
using namespace std;
class A{
public:
	A(char *s) { cout << s << endl; }
	~A(){}
};

class B :virtual public A
{
public:
	B(char *s1, char*s2) :A(s1) { cout << s2 << endl; }
};

class C :virtual public A
{
public:
	C(char *s1, char*s2) :A(s1) { cout << s2 << endl; }
};

class D :public B, public C
{
public:
	// 初始列表执行顺序跟声明有关，继承成员声明顺序，是按继承顺序算的
	D(char *s1, char *s2, char *s3, char *s4) 
		:B(s1, s2)
		, C(s1, s3)
		, A(s1)
	{
		cout << s4 << endl;
	}
};

• 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

一定要搞清楚，初始化的顺序和初始化列表没有任何关系，而是在于声明的顺序，也就是声明继承的顺序，再怎么选也是A和B中选，关键在于是D在前还是A在前

我们说其实构造函数肯定是父类要先于子类啊，再说只有执行完初始化列表之后再能执行构造函数里面的操作不是吗

所以说初始化列表的执行顺序是和声明有关，继承成员声明顺序和初始化列表有关

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

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

class B : public A
{
public:
	// 严格来说，这里就不要给val缺省值了或者跟父类保持一致
	// 充分体现，"选择题险恶", 出题人是真坏
	void func(int val = 100){ 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: 以上都不正确

注意这里不构成的多态，子类指针指向子类不构成多态，必须是父类的指针才能构成多态，但是这里有隐藏的多态p调用了test，这里test中隐含了A*test，这是把父类指针指向了子类对象，此时构成了多态，那么这是应该是B的func

然而最离谱的是，B中的func还不简单，重写了父类的func，其中的val是什么，val是1，不是0

因为这里的缺省参数用的不是我自己的缺省，而是父类的缺省，什么是缺省缺省是一个声明不是初始化因为虚函数的重写是函数的实现，继承的是父类的接口定义，所以声明是不会动的，还是用的父类的声明

严格来说是C++编译器的不好，应该来说缺省参数要一样才让通过，那现在这里缺省值给了也白给

温故知新

什么是多态？

多态是调用函数时是多种形态，分为静态多态和动态多态

静态多态就是函数的重载

动态多态就是父类指针或引用调用重写虚函数

多态的实现原理

有一个虚表，虚表里面有指针，父类指针指向父类对象就调用父类的函数，指向子类对象就去找到子类里面重写的虚函数

inline函数可以是虚函数吗?

首先知道内联函数是没有地址的

但是内联函数成为虚函数之后，该虚函数就会被编译器认为不存在内联属性，因为虚函数的话一定要载虚表里面放一个地址，所以不能再展开了，也就是忽略了内敛属性了

静态成员可以是虚函数吗?

不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

构造函数可以是虚函数吗？

不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。对象还没有初始化出来，虚表指针还没有chu’shi’hua找不到虚表啊

析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

可以，并且最好把父类的析构函数定义成虚函数。
最好多态的话都是虚函数，因为有一个父类指针指向子类或是父类的对象，这时候析构函数肯定要是构成多态的不然的话析构只能调父类的析构，无法析构子类的，所以父类要虚函数

对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。

如果是虚函数构成多态调用的话，要指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

虚函数表是在什么阶段生成的，存在哪的？

虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

C++菱形继承的问题？虚继承的原理？

菱形继承造成的问题是数据冗余，还有就是存在二义性

这里是通过了指针，指向一张表。指针叫虚基表指针，这表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的父类，父类在最下面

什么是抽象类？抽象类的作用？

抽象类用来表示现实世界中没有具体实例对应的抽象类型

抽象类强制重写了虚函数，必须让子类重写，另外抽象类体现出了接口继承关系。