多态的概念
多态的构成条件
1. 必须通过基类的指针或者引用调用虚函数 ，发生切割或切片
为什么不能是派生类？
如果是派生类只能传派生类对象，基类既可以传基类对象又可以传派生类对象，才能实现多态
为什么不能是父类的对象？
对象的切片和指针和引用的切片是有所不同。
子类赋值给父类对象切片，不会拷贝虚表。
如果拷贝虚表，那么父类对象虚表中是父类虚函数还是子类就不确定了，就乱套了。
但是想要实现多态必须把虚表拷贝过去。
不过派生类初始化时，是直接把父辈的虚表拷贝过来，再把进行了重写的虚函数进行覆盖
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual void Func1() {}
virtual void Func2() {}
//protected:
int _a = 0;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
protected:
int _b = 1;
};
int main()
{
Person ps;
Student st;
st._a = 10;
ps = st;
Person* ptr = &st;
Person& ref = st;
return 0;
}
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
不是重写的虚函数
虚函数（在函数最前面加virtual）
只有成员函数才能变成虚函数。
被virtual修饰的类成员函数称为虚函数。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
}；虚函数的重写（覆盖）
构成条件
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
重载是函数名相同，参数不同。
重写是函数名，参数，返回值都相同+虚函数。
虚函数的重写细节
重写的条件本来时候虚函数+三同，但是有一些例外
1.基类的重写虚函数必须加virtual，派生类的重写虚函数可以不加virtual。因为主要重写的是实现。但是建议都要加上。
2.协变，返回值可以不同，但是要求返回值必须是父子关系指针和引用。并且必须同时是指针或者都是引用，而且父是父，子是子，不能一个是指针，另一个是引用
析构函数加virtual，是不是重写？
是，因为析构函数都被处理成了 destructor这个推演名字
为什么要这么处理？
因为要让他们构成重写
那为什么要让他们构成重写呢？
因为下面这个情况
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
void test()
{
cout << "test " << endl;
}
~Student() {
cout << "~Student()" << endl;
delete[] ptr;
}
protected:
int* ptr = new int[10];
};
int main()
{
//Person p;
//Student s;
Person* p = new Person;
p->BuyTicket();
delete p;
p = new Student;
p->BuyTicket();
delete p; // p->destructor() + operator delete(p)
// 这里我们期望p->destructor()是一个多态调用，而不是普通调用
return 0;
}
如果没有构成重写呢？
会可能发生内存泄漏。
两个关键字C++11 override和final
final:修饰虚函数，表示虚函数不能再被重写
override:帮助派生类检查虚函数是否完成重写，如果没有会报错
设计一个不允许被继承的类
方法1：基类构造函数私有（C++98）
因为派生类必须调用父类的构造函数初始化父类成员
这样的话有一个新问题，如何创建基类对象？
提供一个接口函数，并且设置成静态成员函数
这样的话继承的类不是也可以调用？
继承的类根本无法创建出对象，调用这个静态成员函数返回值类型也不匹配
class A
{
public:
static A CreateObj()
{
return A();
}
private:
A()
{}
};
class B : public A
{};
int main()
{
// B bb;
A a=A::CreateObj();
B b=B::CreateObj();//错误
return 0;
}
还有一个方法就是私有析构函数
提供一个静态接口，但是同样有一个问题
解决方法
方法二：利用final关键字（C++11）
重载、覆盖（重写）、隐藏（重定义）的对比
面试题
题目一
/ 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
virtual void Func2()
{
cout << "Func1()" << endl;
}
void Func3()
{
cout << "Func1()" << endl;
}
private:
char _b = 1;
};
int main()
{
cout << sizeof(Base) << endl;
Base b1;
return 0;
}
答案是1？，当然不是，答案是8
为什么呢？
因为多了一个虚表，虚函数都要放在虚表。
当然了，虚表存的是虚函数的地址，虚函数本身还是存在代码段。
题目二
这里是用B类的指针调用是不是就不会形成多态了？
test()只有一份存在代码区，this指针是父类的指针,this->test()是A*。
B只是继承了A，并不会去改变A，也不会在B里面生成一份test()。
所以这个符合第一个多态条件使用父类的指针或引用调用。
缺省值不同会不会影响三同？
不会，三同是返回值相同，函数名相同，参数类型相同
符合第二个多态构成条件三同。
所以答案是D？正确答案B：因为虚函数重写只是重写了实现，整体架子还是使用的父类的。
那这个呢？
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;
}B->0,这this->test()是B*（派生类指针调用），构成多态的第一个条件就没有满足，但是构成隐藏（重定义）
虚表（同类型对象共用一个虚表 ）
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
int _a = 1;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
int _b = 1;
};
void Func(Person& p)
{
// 符合多态，运行时到指向对象的虚函数表中找调用函数的地址
p.BuyTicket();
}
int main()
{
Person Mike;
Func(Mike);
Student Johnson;
Func(Johnson);
return 0;
}
多态调用与普通调用
派生类的虚表生成
派生类（没有自己新增加的虚函数）初始化时，是直接把父辈的虚表拷贝过来，再把进行了重写的虚函数进行覆盖。
重写是语法层的概念，覆盖是原理层的概念。
虚表的细节
虚函数表本质是一个存虚函数指针的函数指针数组，一般情况下这个数组最后面放了一个nullptr。例如vs放了，g++没有放。
派生类自己增加的虚函数放在哪？
派生类的虚表是先拷贝父类的虚表，再覆盖构成多态的虚函数，最后将自己的虚函数放在后面。
通过内存窗口可以查看，在监视窗口里不会显现。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual void Func1()
{
}
virtual void Func2()
{
}
//protected:
int _a = 0;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
private:
virtual void Func3()
{
}
protected:
int _b = 1;
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
st._a = 10;
ps = st;
Person* ptr = &st;
Person& ref = st;
return 0;
}
总结一下派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
c.派生类自己 新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
虚表存储在哪里？
堆区？那谁来malloc，谁来free呢
栈区？那同类型成员怎么共用同一张虚表呢？存在那一个栈帧里呢？栈帧销毁，虚表也就跟着销毁？
打印地址验证虚表存储
因为同一个区里面，偏移量差别不会过大。
因为虚表指针是存在对象的前4个字节，32位平台下（强转成int*再解引用，就可以取得前4个字节的地址）
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual void Func1()
{
cout << "Person::Func1()" << endl;
}
virtual void Func2()
{
cout << "Person::Func2()" << endl;
}
//protected:
int _a = 0;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
private:
virtual void Func3()
{
//_b++;
cout << "Student::Func3()" << endl;
}
protected:
int _b = 1;
};
int main()
{
Person ps;
Student st;
int a = 0;
printf("栈：%p\n", &a);
static int b = 0;
printf("静态区：%p\n", &b);
int* p = new int;
printf("堆：%p\n", p);
const char* str = "hello world";
printf("常量区：%p\n", str);
printf("虚表1：%p\n", *((int*)&ps));
printf("虚表2：%p\n", *((int*)&st));
return 0;
}
根据观察，虚表存储在常量区的概率是最大的，并且虚表也是不能修改的，覆盖是在生成时的。
解决问题经验收集
1.官方文档
2.经典书籍
3.大佬博客
4.自己验证（实践出真知）
（1）看源码
（2）看底层汇编
（3）对照实验
问AI也是不太靠谱的，因为它给你的答案是通过数据整合的，但是如果喂给AI的数据就是有很多错误的话，整合出来的答案也就无法保证准确性
定义函数指针打印虚表
确认派生类新增的虚函数是否存储在虚表里
这里使用的是地址访问，没有this指针，如果成员函数有访问成员变量什么的，直接会崩。
函数有地址就可以直接调用，哪怕是私有成员也可以通过地址直接访问到。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual void Func1()
{
cout << "Person::Func1()" << endl;
}
virtual void Func2()
{
cout << "Person::Func2()" << endl;
}
//protected:
int _a = 0;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
private:
virtual void Func3()
{
//_b++;
cout << "Student::Func3()" << endl;
}
protected:
int _b = 1;
};
typedef void(*FUNC_PTR) ();
// 打印函数指针数组
// void PrintVFT(FUNC_PTR table[])
void PrintVFT(FUNC_PTR* table)
{
for (size_t i = 0; table[i] != nullptr; i++)
{
printf("[%d]:%p->", i, table[i]);
FUNC_PTR f = table[i];
f();
}
printf("\n");
}
int main()
{
Person ps;
Student st;
int vft1 = *((int*)&ps);
PrintVFT((FUNC_PTR*)vft1);
int vft2 = *((int*)&st);
PrintVFT((FUNC_PTR*)vft2);
return 0;
}
多态分类
静态（编译时）的多态，函数重载
动态（运行时）的多态，继承，虚函数重写，实现的多态
在汇编里是直接去调用虚表
多继承的虚表
派生类不会单独产生虚表，在多继承中，继承了基类，就有几张虚表
那么有一个问题，派生类的新增虚函数存在哪张表里？
存第一张？每一张都存？存在最后？
typedef void(*FUNC_PTR) ();
// 打印函数指针数组
// void PrintVFT(FUNC_PTR table[])
void PrintVFT(FUNC_PTR* table)
{
for (size_t i = 0; table[i] != nullptr; i++)
{
printf("[%d]:%p->", i, table[i]);
FUNC_PTR f = table[i];
f();
}
printf("\n");
}
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;
};
int main()
{
Derive d;
cout << sizeof(d) << endl;
int vft1 = *((int*)&d);
//int vft2 = *((int*)((char*)&d+sizeof(Base1)));
Base2* ptr = &d;
int vft2 = *((int*)ptr);
PrintVFT((FUNC_PTR*)vft1);
PrintVFT((FUNC_PTR*)vft2);
return 0;
}
通过stu可以看到派生类的新增虚函数是在第一张虚表的最后。
不过在这种图里还有另外一个问题，为什么重写func1，但是base1和base2的虚表中func1的地址不一样？
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;
};
int main()
{
Derive d;
Base1* ptr1 = &d;
ptr1->func1();
Base2* ptr2 = &d;
ptr2->func1();
Derive* ptr3 = &d;
ptr3->func1();
return 0;
}
打印出来的结果都是一样的。
说明它们的虚表值不一样但是调用的都是同一个函数。
转到反汇编洞察
ptr1的汇编
ptr2的汇编
通过对比，我们可以看出它们最终调用的都是同一个函数地址，只不过ptr2多出来了一步，ecx-8减8
为什么base2要这么做，base1为什么不需要？
因为在这里调用的是Drive的成员，this指针需要指向Drive对象，base1恰好指向对象的最开始，所以base1不需要动。
谁去调用谁就传给this指针，而ecx存的是this指针的值，base1传的是一个正确的this指针，而base2传的是一个错误的this指针。
菱形虚继承+虚函数（叠buff ）
菱形继承
只有两张虚基表
class A
{
public:
int _a;
};
class B : public A
{
public:
int _b;
};
class C : public A
{
public:
int _c;
};
class D : public B, public C
{
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;
}菱形虚拟继承+重写A的虚函数
class A
{
public:
virtual void func1()
{
cout << "A::func1" << endl;
}
public:
int _a;
};
class B :virtual public A
{
public:
virtual void func1()
{
cout << "B::func1" << endl;
}
public:
int _b;
};
class C : virtual public A
{
public:
virtual void func1()
{
cout << "C::func1" << endl;
}
public:
int _c;
};
class D : public B, public C
{
public:
virtual void func1()
{
cout << "D::func1" << endl;
}
virtual void func3()
{
cout << "D::func3" << 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;
}只有一张虚表，两张虚基表
菱形虚拟继承+重写A的虚函数+B和C有自己的虚函数
class A
{
public:
virtual void func1()
{
cout << "A::func1" << endl;
}
public:
int _a;
};
//class B : public A
class B : virtual public A
{
public:
virtual void func1()
{
cout << "B::func1" << endl;
}
virtual void func2()
{
cout << "B::func2" << endl;
}
public:
int _b;
};
//class C : public A
class C : virtual public A
{
public:
virtual void func1()
{
cout << "C::func1" << endl;
}
virtual void func2()
{
cout << "C::func2" << endl;
}
public:
int _c;
};
class D : public B, public C
{
public:
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;
}有三张虚表，两张虚基表，相当炸裂。
在这里我们看到第一个红值是B的虚表，第一个蓝值是B的虚基表。A的虚表跟成员变量放在最后面
有自己独立的虚函数，才会建立虚表。
在这里我们看到虚基表的第一个值不再是零，存的是-4，刚好是跟虚表的偏移量
如果D有自己的虚函数，会不会创建自己的虚表？
不会，因为它直接放到A里面（可能也有不同，按照多继承的角度就是放在B里），子类继承了父类的虚表的话，自己新增的虚函数，是直接放进父类的虚表里。
那么为什么B，C需要建立自己的虚表？
因为菱形虚拟继承，把A拿出来了，这样的话A既不在B里也不在C里，显然再把它们的虚函数放到A的虚表里面是不合适的。
抽象类（这个类在现实世界中没有对应的实体）
不能实例化出对象。
继承的类也是抽象类。
只有重写了纯虚函数，才能实例化出对象
纯虚函数（包含它的类就是抽象类，间接强制派生类重写虚函数）
在虚函数后面+（=0）；
虚函数重写才有意义。
普通的继承是都是实现继承，父类的函数可以是使用
虚函数的继承是接口的继承，继承了接口，重写了实现方法
class Car
{
public:
inline virtual void Drive() = 0;
};
class Benz :public Car
{
public:
inline virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
class BMW :public Car
{
public:
inline virtual void Drive()
{
cout << "BMW-操控" << endl;
}
};
class BYD :public Car
{
public:
inline virtual void Drive()
{
cout << "BYD-build year dream" << endl;
}
};
void Func(Car* p)
{
p->Drive();
p->Func();
}
int main()
{
Func(new Benz);
Func(new BMW);
Func(new BYD);
return 0;
}问答题
1.什么是多态？
（1）静态多态（函数名修饰规则）
比如cout，函数重载
（2）动态多态（虚函数表）
继承中虚函数重写+父类指针（引用）调用
更方便和灵活多种形态的调用
2.内联函数可以是虚函数嘛？
可以编译通过，但是编译器会把它变成非内联函数，因为内联函数没有地址，而虚函数地址要放进虚函数表里。
在类里面定义不需要写inline，因为在类里面定义默认成为内联（但是最终还是要取决于编译器）。
class Car
{
public:
int Func()
{
int a = 0;
int b = 2;
return a + b;
}
};
void Func(Car* p)
{
p->Func();
}
int main()
{
Func(new Car);
return 0;
}
声明和定义分离后，就不会是内联函数。
class Car
{
public:
int Func();
};
int Car::Func()
{
int a = 0;
int b = 2;
return a + b;
}
void Func(Car* p)
{
p->Func();
}
int main()
{
Func(new Car);
return 0;
}
3.静态成员函数，可不可以是虚函数？
不可以，因为静态成员函数没有this指针，所以它可以不通过对象调用，也无法访问全部成员
4.构造函数可不可以是虚函数？
虚表在编译阶段生成好，
那么虚表指针在什么阶段初始化？
在构造函数初始化列表时初始化，先初始化虚表，再初始化成员
想要实现多态，就要对象去调用。
5.析构函数可以是虚函数嘛？
当然可以，并且最好把基类的析构函数加上virtual
6.对象访问普通函数快还是虚函数更快？
如果不构成多态，两者是一样的。
如果构成多态，运行时虚函数要去虚表里面查找，因此普通函数更快
7.虚函数表是在什么阶段生成，存在哪？
编译阶段生成，在构造函数里初始化，存在常量区。
8.C++菱形继承的问题？虚继承的原理？
数据冗余和二义性。虚基表。
2006
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
