记录我自己零开始学习C++。
目录
[2.1 虚函数](#2.1 虚函数)
[2.2 虚函数的重写](#2.2 虚函数的重写)
[2.2.1 正常情况下：](#2.2.1 正常情况下：)
[2.2.2 当两个类不构成多态时：](#2.2.2 当两个类不构成多态时：)
[2.2.3 两个类构成多态时：](#2.2.3 两个类构成多态时：)
[2.3 C++11 override 和 final](#2.3 C++11 override 和 final)
[2.4 重载、覆盖(重写)、隐藏(重定义)的对比](#2.4 重载、覆盖(重写)、隐藏(重定义)的对比)
[2.4.1 重载](#2.4.1 重载)
[2.4.3 隐藏(重定义）](#2.4.3 隐藏(重定义）)
[3.2 接口继承和实现继承](#3.2 接口继承和实现继承)
[4.3 动态绑定与静态绑定](#4.3 动态绑定与静态绑定)
一、多态的概念
多态（Polymorphism）是面向对象编程（OOP）的三大核心特性之一（另外两个是封装和继承），其核心思想是："同一行为（或接口），在不同对象上有不同的实现和表现"。简单来说，就是通过统一的接口调用，不同的对象会根据自身特性做出不同的响应。
举个栗子：比如 买票这个行为 ，当 普通人 买票时，是全价买票； 学生 买票时，是半价买票； 军人
买票时是优先买票。
再比如：同样是 "支付" 这个动作，用不同的方式会有不同结果，用现金支付，需要掏出钱包、数钱、找零；用手机支付，打开 APP、扫码、输入密码；用银行卡支付，插卡、输密码、签字。
二、多态的定义及实现
比如使用多态完成买票行为：
cpp
#include<iostream>
using namespace std;
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Soldier : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-优先" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
//void Func(Person* p)
//{
// p->BuyTicket();
//}
int main()
{
Person p;
Student st;
Soldier so;
Func(p);
Func(st);
//Func(&so);
//Func(&st);
return 0;
}
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：
1. 必须通过基类的指针或者引用调用虚函数。
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
多态调用：仅发生在 "基类指针 / 引用调用虚函数" 时，核心是动态绑定，看实际指向的对象类型。
普通调用：包括 "调用非虚函数""对象直接调用（无论是否虚函数）"，核心是静态绑定，看调用者的编译时类型。
2.1 虚函数
虚函数：即被 virtual 修饰的类成员函数称为虚函数。
cpp
class Person {
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};2.2 虚函数的重写
虚函数的重写(覆盖) ：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
cpp
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
//前面不加virturl，此时也构成重写
//void BuyTicket()
//{
// cout << "买票-半价" << endl;
//}
};注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，也可以构成重写(因为此时是用(继承了)父类的接口声明 + 子类重写了函数实现)，但是该种写法不是很规范，不建议这样使用。
虚函数重写的两个例外：
(1) 协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变(了解)。
cpp
class A{};
class B : public A {};
class Person {
public:
virtual A* f() {return new A;}
};
class Student : public Person {
public:
virtual B* f() {return new B;}
};(2) 析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
2.2.1 正常情况下：
cpp
class Person
{
public:
~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
delete _ptr;
cout << "~Student()" << endl;
}
protected:
int* _ptr = new int[10];
};
int main()
{
//当父类析构不加virtual时：
Student s;
return 0;
}
正常情况下，先调用子类的析构函数，子类调用完后自动调用父类析构，子类中的资源清理完成，这是调用正常的。
2.2.2 当两个类不构成多态时：
cpp
class Person
{
public:
~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
delete _ptr;
cout << "~Student()" << endl;
}
protected:
int* _ptr = new int[10];
};
int main()
{
//此时p1指向的是一个子类的对象，但调的却是父类的析构函数
//如果像上面的子类，就无法清理资源，会发生内存泄漏
Person* p1 = new Student;
delete p1;
return 0;
}
Person* p1 = new Student;：基类指针p1指向派生类Student的对象。Student对象中包含动态分配的_ptr（new int[10]），需要在析构函数中释放。
delete p1;：由于Person的析构函数不是虚函数，此时编译器会根据p1的静态类型（Person*）调用Person的析构函数，而不会调用Student的析构函数。
2.2.3 两个类构成多态时：
cpp
class Person
{
public:
virtual ~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
delete _ptr;
cout << "~Student()" << endl;
}
protected:
int* _ptr = new int[10];
};
int main()
{
Person* p1 = new Student;
delete p1;
//Person* p2 = new Person;
//delete p2; // 仅调用Person的析构函数，输出~Person()
//如果本身指向的是一个父类的对象，调的只是父类的析构函数
return 0;
}
由于Person的析构函数是虚函数，且p1实际指向的是Student对象，因此：
第一步会先调用Student的析构函数：执行delete[] _ptr;（释放Student中动态分配的数组），并输出~Student()；
接着自动调用基类Person的析构函数（析构函数的调用遵循 "先派生类后基类" 的规则），输出~Person()。
2.3 C++11 override 和 final
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。
2.3.1 final：修饰虚函数，表示该虚函数不能再被重写
cpp
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};2.3.2 override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
cpp
class Car
{
public:
virtual void Drive(){}
};
class Benz :public Car
{
public:
virtual void Drive() override
{
cout << "Benz-舒适" << endl;
}
};2.3.3 要想一个类不能被继承：
1.final是 C++11 引入的关键字，直接修饰类时，表示该类是 "最终类"，禁止任何类继承它。这是最直接、最清晰的方式。
2.如果父类的所有构造函数（包括默认构造、拷贝构造等）都是private，那么子类在初始化时无法调用父类的构造函数（子类构造函数必须先初始化父类部分），导致子类无法实例化，间接实现 "不能被继承" 的效果。
2.4 重载、覆盖(重写)、隐藏(重定义)的对比
它们的核心区别体现在作用域、函数关系、调用规则等方面。
2.4.1 重载
场景 ：同一类中，多个函数名相同但参数不同的函数。
关键：仅关注 "同一作用域 + 同名 + 不同参"，与继承无关。
cpp
class Math {
public:
// 重载1：参数为int
int add(int a, int b) { return a + b; }
// 重载2：参数为double（与上一个参数不同）
double add(double a, double b) { return a + b; }
// 重载3：参数个数不同（1个参数）
int add(int a) { return a; }
};
int main() {
Math m;
m.add(1, 2); // 调用add(int, int)
m.add(1.5, 2.5); // 调用add(double, double)
m.add(5); // 调用add(int)
return 0;
}2.4.2覆盖(重写)
场景 ：继承中，派生类重写基类的虚函数 ，函数原型完全相同。
关键："继承 + 虚函数 + 同原型"，是实现运行时多态的核心。
cpp
class Animal {
public:
virtual void makeSound() { // 基类虚函数
cout << "动物叫" << endl;
}
};
class Dog : public Animal {
public:
// 覆盖（重写）基类虚函数：函数名、参数、返回值完全相同
void makeSound() override { // override关键字可选，用于检查重写是否正确
cout << "汪汪" << endl;
}
};
int main() {
Animal* animal = new Dog(); // 基类指针指向派生类对象
animal->makeSound(); // 运行时绑定：调用Dog的makeSound()（多态）
return 0;
}2.4.3 隐藏(重定义）
场景 ：继承中，派生类与基类有同名函数，但不满足覆盖条件（如基类非虚函数，或参数不同），导致基类函数被 "隐藏"。
关键：派生类同名函数会 "屏蔽" 基类函数，调用时只看调用者的静态类型。
情况 1：基类函数非虚函数，派生类同名同参
cpp
class Base {
public:
void func() { // 基类非虚函数
cout << "Base::func()" << endl;
}
};
class Derived : public Base {
public:
void func() { // 派生类同名同参函数（非覆盖，因基类非虚函数）
cout << "Derived::func()" << endl;
}
};
int main() {
Derived d;
d.func(); // 调用Derived::func()（派生类隐藏基类）
d.Base::func(); // 需显式指定作用域才能调用基类函数
Base* b = &d;
b->func(); // 调用Base::func()（看调用者类型Base*）
return 0;
}情况 2：基类与派生类同名但参数不同（无论是否虚函数）
cpp
class Base {
public:
virtual void func(int x) { // 基类虚函数（参数int）
cout << "Base::func(int)" << endl;
}
};
class Derived : public Base {
public:
void func(double x) { // 派生类同名但参数不同（double）
cout << "Derived::func(double)" << endl;
}
};
int main() {
Derived d;
d.func(1.5); // 调用Derived::func(double)
d.func(1); // 仍调用Derived::func(double)（int隐式转double）
d.Base::func(1); // 需显式调用基类函数
Base* b = &d;
b->func(1); // 调用Base::func(int)（基类函数未被覆盖，因参数不同）
return 0;
}三、抽象类
3.1概念
在虚函数的后面写上 =0 ，则这个函数为纯虚函数 。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
(1)抽象类的派生类如果没有重写基类中所有的纯虚函数 ，那么这个派生类仍然是抽象类（无法实例化）。只有当派生类全部重写了基类的纯虚函数，它才会成为 "具体类"，才能创建对象。
(2)普通虚函数体现 "实现继承"：派生类可以继承基类的函数实现（如果不重写，就使用基类的实现）。纯虚函数体现 "接口继承"：基类只定义接口（函数声明），不提供实现，强制派生类必须自己实现（规范派生类的行为）。这也是纯虚函数常用于定义 "接口类" 的原因。
(3) 纯虚函数可以有函数体（语法允许），但声明时必须加=0，且派生类仍然必须重写该函数（不能直接使用基类的实现）。
cpp
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;
}
};
//均继承自Car，并重写了纯虚函数Drive()，因此它们是 "具体类"（非抽象类），可以实例化对象。
int main()
{
Car* pBenz = new Benz;
pBenz->Drive();//pBenz指向Benz对象 → 调用Benz::Drive()，输出Benz-舒适；
Car* pBMW = new BMW;
pBMW->Drive();//pBMW指向BMW对象 → 调用BMW::Drive()，输出BMW-操控。
return 0;
}3.2 接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
四、多态的原理(重点)
4.1虚函数表
cpp
// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
那么派生类中这个表放了些什么呢？我们接着往下分析：
针对上面的代码我们做出以下改造：
1.我们增加一个派生类Derive去继承Base；
2.Derive中重写Func1；
3.Base再增加一个虚函数Func2和一个普通函数Func3
cpp
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;
}
通过观察和测试，我们发现了以下几点问题：
(1) 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员.
(2) 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
(3) 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
(4) 虚函数表本质是一个存虚函数指针的函数指针数组，一般情况这个数组最后面放了一个nullptr。
(5) 总结一下派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中 ;
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 ;
c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
(6) 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？
注意：
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针(对象的前4个字节是虚表的指针)。
那么虚表存在哪的呢？
实际我们去验证一下会发现vs下是存在代码段(常量区)的。
cpp
int main()
{
int i = 0;
static int j = 0;
int* p1 = new int;
const char* p2 = "11111111";
printf("栈:%p\n", &i);
printf("静态区:%p\n", &j);
printf("堆:%p\n", p1);
printf("常量区:%p\n", p2);
cout << endl;
Base b;
Derive d;
printf("Base虚表地址:%p\n", (*(int*)&b));
printf("Derive虚表地址:%p\n", (*(int*)&d));
cout << endl;
printf("Base对象地址:%p\n", &b);
printf("Derive对象地址: %p\n", &d);
cout << endl;
return 0;
}
总结：
(1) 虚表是类级别的函数指针数组，存储当前类中所有虚函数的地址，编译时由编译器生成，存放在常量区（或代码段，因编译器实现略有差异），属于只读共享资源。
(2) 虚表的每个元素都是虚函数的地址（函数指针）。若派生类重写基类虚函数，虚表中对应位置会被替换为派生类的虚函数地址；未重写的虚函数则保留基类地址；新增虚函数会追加到虚表末尾。
(3) 无论是虚函数还是普通函数，其函数体（可执行代码）都存放在代码段（程序的指令区），区别仅在于：虚函数的地址会被编译器放入虚表，而普通函数的调用直接通过函数名寻址。
(4) 每个包含虚函数的类的对象，都会隐含一个虚表指针（vptr），其值指向当前对象所属类的虚表。vptr 是对象的成员（隐藏在对象内存布局中），占 4/8 字节（32/64 位系统），因此含虚函数的对象比同类型非虚函数对象 "大" 一个指针的大小。
(5) 同一类的所有对象共享同一个虚表（虚表是类的静态资源）。例如，所有Dog类对象的 vptr 都指向Dog类的虚表，不会为每个对象单独生成虚表。
(6) 动态多态（运行时多态）：核心是 "虚函数 + 继承 + 基类指针 / 引用"，依赖虚表和 vptr 实现，函数调用在运行时通过 vptr 查虚表确定具体函数，是面向对象多态的典型体现。
静态多态（编译时多态）：广义上包括函数重载（同一类内同名不同参）、函数模板（泛型编程），函数调用在编译时通过参数匹配确定，不依赖虚函数机制，性能更高但灵活性较低。
4.2多态的原理
上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket。
cpp
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;
}(1) 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
(2) 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
(3) 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
(4) 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
(5) 再通过汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
4.3 动态绑定与静态绑定
(1) 运行时绑定/动态绑定：
满足多态，那么这里调用生成的指令时，运行时就会去指向对象的虚表中找到对应的虚函数的地址，指向谁调用谁。
(2) 编译时绑定/静态绑定：
不满足多态，普通函数的调用，如果只有声明，就通过函数名在链接的时候找到地址调用，如果有声明和定义，就通过函数名在符号表中找到地址，跟指向的对象无关。
五、多继承的虚表
cpp
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;
}