多态的概念
通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会
产生出不同的状态。
举个例子：比如
买票这个行为
，当
普通人
买票时，是全价买票；
学生
买票时，是半价买票；
军人
买票时是优先买票。
多态的定义及实现
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student
继承了
Person
。
Person
对象买票全价，
Student
对象买票半价。
在继承中要
构成多态还有两个条件
：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
虚函数和虚函数的重写
虚函数：即被virtual
修饰的类成员函数称为虚函数。
class Person
{
public:
virtual void BuyTicket()
{
cout << "buy full price ticket" << endl;
}
};
虚函数的重写
(
覆盖
)
：
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同)
，
称子类的虚函数重写了基类的虚函数。
class Person
{
public:
virtual void BuyTicket()
{
cout << "buy full price ticket" << endl;
}
};
class Student:public Person
{
public:
virtual void BuyTicket()
{
cout<<"Buy at half price ticket"<<endl;
}
};
void test1(Person&p)
{
p.BuyTicket();
}
int main()
{
Person p1;
test1(p1);
Student s;
test1(s);
return 0;
}虚函数重写的两个例外
协变
派生类重写基类虚函数时，与基类虚函数返回值类型不同。
即基类虚函数返回基类对象的指
针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
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;}
};析构函数的重写
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，
无论是否加virtual关键字，
都与基类的析构函数构成重写
，虽然基类与派生类析构函数名字不同。虽然函数名不相同，
看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处
理，编译后析构函数的名称统一处理成
destructor
。
class Person {
public:
virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
//数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
编译后析构函数的名称统一处理成destructor
C++11 override 和 final
final
：修饰虚函数，表示该虚函数不能再被重写
override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
重载、覆盖(重写)、隐藏(重定义)的对比
抽象类
在虚函数的后面写上
=0
，则这个函数为纯虚函数。
包含纯虚函数的类叫做抽象类（也叫接口
类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生
类才能实例化出对象。
纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实 现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成 多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数
多态的原理
虚函数表
class Person
{
public:
virtual void BuyTicket()
{
cout << "buy full price ticket" << endl;
}
virtual void Func()
{
cout << "Func" << endl;
}
int a = 0;
};
class Student:public Person
{
public:
virtual void BuyTicket()
{
cout<<"Buy at half price ticket"<<endl;
}
int b = 0;
};
void test(Person&p)
{
p.BuyTicket();
}
int main()
{
Person p1;
test(p1);
Student s1;
test(s1);
cout << endl;
return 0;
}
我们发现对象里面有一个_vfptr，对象中的这个指针我们叫做虚函数表指针(v代 表virtual，f代表function)。
原理
class Person
{
public:
virtual void BuyTicket()
{
cout << "buy full price ticket" << endl;
}
virtual void Func()
{
cout << "Func" << endl;
}
int a = 0;
};
class Student:public Person
{
public:
virtual void BuyTicket()
{
cout<<"Buy at half price ticket"<<endl;
}
int b = 0;
};
void test(Person&p)
{
p.BuyTicket();
}
int main()
{
Person p1;
test(p1);
Student s1;
test(s1);
cout << endl;
return 0;
}
1. 观察图的箭头我们看到，p是指向p1对象时，p->BuyTicket在p1的虚表中找到虚函数是Person::BuyTicket。2. 观察图的蓝色箭头我们看到，p是指向s1对象时，p->BuyTicket在s1的虚表中 找到虚函数是Student::BuyTicket。3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
看出满足多态以后的函数调用，不是在编译时确定的，是运行 起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
动态绑定与静态绑定
静态绑定又称为前期绑定 ( 早绑定 ) ， 在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载动态绑定又称后期绑定 ( 晚绑定 ) ， 是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
单继承和多继承关系的虚函数表
单继承中的虚函数表
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() { cout << "Base::func2" << endl; }
private:
int a;
};
class Derive :public Base {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
virtual void func4() { cout << "Derive::func4" << endl; }
private:
int b;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Base b;
Derive d;
VFPTR * vTableb = (VFPTR*)(*(int*)&b);
PrintVTable(vTableb);
VFPTR* vTabled = (VFPTR*)(*(int*)&d);
PrintVTable(vTabled);
cout << endl;
return 0;
}
我们可以通过运行结果得知其结构。
多继承中的虚函数表
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(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVTable(vTableb2);
cout << endl;
return 0;
}
同理：
课后练习
1、p1,p2,p3大小关系？
class Base1
{
public:
int _b1 = 0;
};
class Base2
{
public:
int _b2 = 0;
};
class Derive : public Base1, public Base2
{ public: int _d = 0; };
int main()
{
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
return 0;
}2，下面程序输出结果为？
#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;
}
};
int main() {
D* p = new D ("class A", "class B", "class C", "class D");
delete p;
return 0;
}
答案
1，通过监视窗口我们可以观察到如图。
可得出其结构为：
2，
在C++中，当一个类通过虚拟继承另一个类时，最远的基类（在这里是A）会首先被初始化。这是为了确保基类只被初始化一次，以避免数据的冗余和不一致。B和C都是从A虚拟继承而来，D则从B和C继承。因此，当创建D类的对象时，首先会调用A类的构造函数，然后按照声明的顺序（class D : public B, public C）调用B和C的构造函数，最后调用D的构造函数。
652
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
