C++——多态
1.概念
通俗来说，就是多种形态,具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态
就比如说：
买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
2.定义及其实现
2.1构成条件
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2.2虚函数
那么什么是虚函数呢？
我们把被virtual修饰的类成员函数称之为虚函数
//多态 人 学生 不同类创建的对象调同一个函数得到不同的结果
class Person
{
public:
//虚函数
virtual void BuyTicket()
{
cout << "全价买票" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "半价买票" << endl;
}
};
void Func(Person& people)
{
people.BuyTicket();
}
void Test()
{
Person Mike;
Func(Mike);
Student John;
Func(John);
}
int main()
{
return 0;
}
2.2.1虚函数的重写(覆盖)
派生类中有一个和基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名、参数列表完全相同)，称子类的虚函数重写了基类的虚函数
class Person
{
public:
virtual void BuyTicket()//父类虚函数
{
cout << "全价买票" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()//子类重写父类虚函数
{
cout << "半价买票" << endl;
}
};注意：
在重写基类虚函数时，派生类的虚函数不加virtual也可以构成重写(只不过这种写法不是很规范，不建议这样使用)
2.2.2重写例外
1.协变：基类与派生类虚函数返回值类型不同
虚函数返回值类型可以不同，但是必须是父子类关系的指针或者引用
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。
class Person
{
public:
virtual ~Person()
{
cout << "Person()" << endl;
}
};
class Student:public Person
{
public:
virtual ~Student()
{
cout << "Student()" << endl;
}
};
int main()
{
Person* p1 = new Person;
delete p1;
Person* p2 = new Student;
delete p2;
return 0;
}2.2.3重载、覆盖(重写)、隐藏(重定义)对比
重载
两个函数在同一作用域
函数名参数相同
重写(覆盖)
两个函数分别在基类和派生类的作用域
函数名/参数/返回值类型必须都相同(协变除外)
两个函数必须是虚函数
重定义(隐藏)
两个函数必须在基类和派生类的作用域
函数名相同
两个基类和派生类同名函数不构成重写就是重定义
2.2.4补充
C++11增加了override和final
1. final：修饰虚函数，表示该虚函数不能再被重写
2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
3.抽象类
3.1 概念
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口
类），抽象类不能实例化出对象。 派生类继承后也不能实例化出对象，只有重写纯虚函数 ，派生
类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
class car
{
public:
virtual void Drive() = 0;
};
class Benz :public car
{
public:
virtual void Drive()
{
cout << "Benz" << endl;
}
};
int main()
{
car* pBenz = new Benz;
pBenz->Drive();
return 0;
}
3.2接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实
现。
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成
多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
4.多态的原理
4.1虚函数表
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
private:
int _b = 10;
};
int main()
{
Base b;
cout<先计算一下sizeof(b)是多少？
明明只有一个成员变量_b，为什么计算的结果是8呢？
有了虚函数后对象里面会多一个指针，叫虚函数表指针
除了_b成员，还多一个__vfptr放在对象的前面(放的位置 跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代 表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数地址要被放到虚函数表中，虚函数表也简称虚表。
那么派生类中这个表放了些什么呢？
增加一个派生类Derive去继承Base
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
private:
int _d = 0;
}; 
派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚
表指针也就是存在部分的另一部分是自己的成员。
基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表
中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数
的覆盖。重写是语法的叫法，覆盖是原理层的叫法
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函
数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr
总结一下派生类的虚表生成：
先将基类中的虚表内容拷贝一份到派生类虚表中如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
补充几个问题
多个虚函数在虚表中谁先谁后呢？先声明的在前面虚函数存在哪的？虚表存在哪的？虚函数和普通函数一样的，都是存在代码段的， 只是 它的指针又存到了虚表中。
虚表存的是虚函数指针 (满足多态调用的时候，运行时到指向的对象中找到对应的虚函数)。另外对象中存的不是虚表，存的是虚表指针。实际我们去验证一下会发现vs下虚表是存在代码段的
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
private:
int _d = 0;
};
int main()
{
Base b1;
Drive d1;
int i = 0;
static int j = 1;
int* p = new int;
const char* p1 = "sdhajsd";
printf("栈:%p\n", &i);
printf("静态区:%p\n", &j);
printf("堆:%p\n", p);
printf("常量区:%p\n",p1);
Base* p2 = &b1;
Drive* p3 = &d1;
printf("Base:%p\n",*(int*)p2);
printf("Drive:%p\n",*(int*)p3);
return 0;
}
看着是常量区的
4.2多态的原理
看一下下面的代码思考一个问题
怎么做到指向父类的调用父类，指向子类的调用子类？
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
private:
int _d = 0;
};
void f(Base* ptr)
{
ptr->Func1();
}
int main()
{
Base b;
Drive d;
f(&b);
f(&d);
return 0;
}
函数f去父类中通过虚函数表指针在虚函数表中找虚函数
但是父类可能是原生父类虚函数指针(指向Base::Func1())
也可能是子类当中继承(切割)出来后被覆盖的指针(指向Drive::Func1())
这样就实现出了不同对象去完成同一行为时，展现出不同的形态
这也说明了多态调用实现是依靠运行时去指向对象的虚表中查，调用函数地址
4.3运行时决议和编译时决议
看一下以下代码
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
private:
int _d = 0;
};
//运行时决议和编译时决议
int main()
{
Base b;
Drive d;
Base* p = &b;
p->Func1();
p->Func3();
p = &d;
p->Func1();
p->Func3();
return 0;
}这里 Func3 为什么不是 Derive 的？因为 Func3 不是虚函数，它没有进入虚表。
如果从更深的角度 —— 汇编层面去看，就可以牵扯出编译时决议和运行时决议。
决议的意思是如何确定函数的地址可以在运行时确定（多态调用）或在编译时确定（普通调用）多态调用是在运行时去虚函数表中找虚函数地址，然后进行调用(多态底层实现的原理)，所以指向父类调的是父类虚函数，指向子类调用的是子类虚函数而普通调用是在编译时通过调用者类型来确定函数的地址(看p是什么类型，和对象没有关系)
4.4动态绑定与静态绑定
静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态， 比如：函数重载动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
5.单继承和多继承关系的虚函数表
5.1 单继承中的虚函数表
上代码
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
virtual void Func3()
{
cout << "Drive::Func3()" << endl;
}
virtual void Func4()
{
cout << "Drive::Func4()" << endl;
}
private:
int _d = 0;
};
int main()
{
Base b;
Drive d;
return 0;
}
看不到Func3和Func4
这里是vs编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？
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 = 10;
};
class Drive :public Base
{
public:
virtual void Func1()
{
cout << "Drive::Func1()" << endl;
}
virtual void Func3()
{
cout << "Drive::Func3()" << endl;
}
virtual void Func4()
{
cout << "Drive::Func4()" << endl;
}
private:
int _d = 0;
};
typedef void(*VF_PTR) ();
void PrintVTable(VF_PTR vft[])
{
//打印虚表本质是打印指针(虚函数指针)数组
//数组中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vft<< endl;
for (int i = 0; vft[i] != nullptr; ++i)
{
printf("[%d]:%p->", i, vft[i]);
VF_PTR f = vft[i];//函数指针去接收地址
f();//通过这个地址去调函数
}
cout << endl;
}
int main()
{
Base b;
Drive d;
VF_PTR * vft1 = (VF_PTR*)(*(int*)&b);
PrintVTable(vft1);
VF_PTR* vft2 = (VF_PTR*)(*(int*)&d);
PrintVTable(vft2);
return 0;
} 取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
指针的指针数组，这个数组最后面放了一个nullptr
先取b的地址，强转成一个int*的指针
再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
再强转成VF_PTR*，因为虚表就是一个存VF_PTR类型(虚函数指针类型)的数组。
虚表指针传递给PrintVTable进行打印虚表
需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。
5.2多继承中的虚表
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(*VF_PTR) ();
void PrintVTable(VF_PTR vft[])
{
//打印虚表本质是打印指针(虚函数指针)数组
//数组中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vft<< endl;
for (int i = 0; vft[i] != nullptr; ++i)
{
printf("[%d]:%p->", i, vft[i]);
VF_PTR f = vft[i];//函数指针去接收地址
f();//通过这个地址去调函数
}
cout << endl;
}
int main()
{
Derive d;
cout << sizeof(d) << endl;
Base1* ptr1 = &d;
Base2* ptr2 = &d;
PrintVTable((VF_PTR*)(*(int*)ptr1));
PrintVTable((VF_PTR*)(*(int*)ptr2));
return 0;
}可以看到d中明显有两张虚表
观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
