在上一篇文章中，我们对C++的继承进行了详细的讲解，不知道大家掌握的怎么样呢，在这篇文章中我们将要对C++的多态进行详细的讲解，多态是在继承的前提下产生的，也是十分重要的内容，下面我们一起来看看吧。
补充:
在这里需要先声明一下，本文章的代码和解释都是在vs2019下的x86程序中，设计的指针都是4bytes，在其他的平台下，可能部分的代码需要改动，比如x64程序，需要考虑指针是8bytes问题等等
**多态的概念:**通俗的来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
举个栗子
举一个很贴近我们生活的例子，比如说买票的这个行为，当普通人买票时，是全价买票，学生买票时，是半价买票，军人买票时是优先买票。这就构成了一个多态。
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person，Soldier继承了Person。Person对象买票全价，Student对象买票半价，军人优先买票。
在继承中要构成多态还要有两个条件:
1.必须通过基类的指针或者引用调用虚函数
2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
总结:
就是以下两句话
多态的两个条件:
1.虚函数重写(这里本身就指定了必须是虚函数)
2.父类指针或者引用去调用虚函数
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
class Soldier :public Person
{
public:
virtual void BuyTicket()
{
cout << "优先买票" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
看输出结果。
这里我们可以看以不同的类对象去调用同一个函数会出现不同的状态，这个现象就是多态，是不是很神奇。
虚函数: 即被virtual修饰的类成员函数称为虚函数。
在上面的例子中，我们看到了在讲述继承的时候出现的一个关键字，virtual，但是我们需要注意的是这两个地方的virtual是不同的，大家一定要区分开。
class Person
{
public:
//这里的BuyTicket就是虚函数
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
//特例1:在重写基类函数时，子类虚函数不加 virtual时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用。
//void BuyTicket()
//{
// cout << "买票-半价" << endl;
//}
};
class Soldier :public Person
{
public:
virtual void BuyTicket()
{
cout << "优先买票" << endl;
}
};
//多态的两个条件
//1.虚函数重写
//2.父类指针或者引用去调用虚函数
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
既然我们已经知道了构成的多态的条件，下面我们就来探究一下。我们来看一下修改其中的几个条件，是否还能构成的多态。
下面我们将virtual关键字去掉，看看是否能构成多态。
class Person
{
public:
void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
class Soldier :public Person
{
public:
void BuyTicket()
{
cout << "优先买票" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
通过输出结果我们可以看到这里是没有构成多态的。
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
class Soldier :public Person
{
public:
virtual void BuyTicket()
{
cout << "优先买票" << endl;
}
};
void Func(Person p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
看上面的代码，我们可以看到去掉的条件是:不是父类的指针或者引用调用，再看下面的输出结果。
这里也是不能构成多态的。
//(3)多态条件探究三:不符合重写 -- 参数不同
class Person
{
public:
virtual void BuyTicket(int)
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
//Student中函数的参数类型与父类不同
virtual void BuyTicket(char)
{
cout << "买票-半价" << endl;
}
};
class Soldier :public Person
{
public:
//Soldier中函数的参数类型与父类相同
virtual void BuyTicket(int)
{
cout << "优先买票" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket(1);
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
为了直接将结果进行对比，我们这里进行了一下修改，Student中函数的参数类型与父类不同，Soldier中函数的参数类型与父类相同。
直接看结果。
分析结果:
我们查看结果可知，Student与父类没有构成多态，Soldier与父类构成了多态。
class Person
{
public:
virtual int BuyTicket()
{
cout << "买票-全价" << endl;
return 0;
}
};
class Student :public Person
{
public:
//Student中函数的返回值类型与父类不同
virtual double BuyTicket()
{
cout << "买票-半价" << endl;
return 1.1;
}
};
class Soldier :public Person
{
public:
//Soldier中函数的返回值类型与父类相同
virtual int BuyTicket()
{
cout << "优先买票" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
看这里的输出，我们就知道以这一种方式都无法通过编译，所以这种方式是完全错误的，但是在输出窗口中我们看到提示信息中出现了协变二字，那这里的协变指的是什么呢，我们下面就会讲到。
以上就是我们所讲的四种多态条件的探究，在虚函数重写的条件中还有一条是函数名必须相同，这个很好理解，我们就不多说了。
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）
class Person
{
public:
//返回父类的指针
virtual Person* BuyTicket()
{
cout << "买票-全价" << endl;
return this;
}
};
class Student :public Person
{
public:
//返回子类的指针
virtual Student* BuyTicket()
{
cout << "买票-半价" << endl;
return this;
}
};
class Soldier :public Person
{
public:
//返回子类的指针
virtual Soldier* BuyTicket()
{
cout << "优先买票" << endl;
return this;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
在这里虚函数的返回值可以是父类和子类的指针或者引用，这就叫做协变。
协变下的特殊情况
class A
{};
class B :public A
{};
class Person
{
public:
virtual A* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student :public Person
{
public:
virtual B* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}
};
class Soldier :public Person
{
public:
virtual B* BuyTicket()
{
cout << "优先买票" << endl;
return nullptr;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Soldier sd;
Func(ps);
Func(st);
Func(sd);
return 0;
}
看这一部分代码，A和B构成了父类与子类的关系，A是B的父类，B是A的子类，然后我们发现可以在后面的代码中直接使用A类与B类的指针，这里也是可以正常构成多态的。这就是协变最特殊的情况。
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，
看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，但是这里为什么要让派生类的析构函数与基类构成虚函数的重写呢？我们一起来分析一下。
看下面的代码
1.不将父类的析构函数定义为虚函数
class Person
{
public:
~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:
//析构函数名会被处理成destructor，所以这里析构函数完成虚函数重写
~Student() { cout << "~Student()" << endl; }
};
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
分析代码:我们看上面的代码，没有将父类的析构函数定义为虚函数，那么也就不会有多态行为的产生，意思就是说当我们定义完对象后析构的时候会各自调用各自的析构函数，听着确实没有毛病，但是我们看给出的这一种情况，我们定义了两个父类的指针分别指向父类对象和子类对象，那么按照计划，在调用结束的时候子类调用子类的析构函数，父类调用父类的析构函数，但是我们看输出结果却不是这样的。
这里的输出表明我们只调用了父类的析构函数，这是不合理的，因为我们的Student对象应该去调用Student的析构函数，所有编译器才对这里进行了处理，我们看下面的代码。
class Person
{
public:
virtual ~Person() { cout << "~Person()" << endl; }
};
class Student: public Person
{
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
通过对输出结果的分析，我们可以得知这里分别调用了父类和子类的析构函数。
最后我们以一张图对上面的内容进行总结。
既然我们已经对多态有了一定的了解了，下面我们来做一道题来运用一下，先说好，这个题很恶心，细节也是非常多的。
大家心里是否已经有答案了呢，这里我们公布正确的答案，这个题选择B，有的小盆友看了是不是大吃一惊，心里全是问号，并问这是为啥，别着急，下面我们一起来详细的分析一下。
这道题看着十分简单，但是坑却不少，一不小心就会跳进去。
有的小伙伴还是不理解这里到底为什么会去调用子类的函数，什么原理?大家这里其实只要记住指针指向谁就会去调用谁的函数。下面我们先简单的去看一下构成时的底层到底是什么样子的。
这里我们不整那么繁琐，还是以我最初给大家的代码为主。
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 p;
Func(p);
Student s;
Func(s);
}
代码比较简单，也更容易理解。
这里是可以构成多态的，那么我们直接看他们的底层到底是什么样子的。
后面我会给大家更详细的介绍虚表，所以更多的只是还在后面。
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。
final:修饰虚函数，表示该虚函数不能再被重写。
class A
{
public:
virtual void Func() final {}
};
class B: public A
{
public:
virtual void Func() { cout << "Func" << endl; }
};
我们看这里的输出信息，可以发现Func声明为final后，是无法被B::Func重写的。
override:检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class A
{
public:
virtual void Func(){}
};
class B: public A
{
public:
virtual void Func1() override {}
};
这里我没有让派生类对基类的虚函数进行重写，这时候就会报出没有重写的错误。
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。**包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。**派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
class Car
{
public:
virtual void Driver() = 0;
};
class BMW :public Car
{
//没有实现对虚函数的虚写
};
class Benz :public Car
{
public:
//实现了对虚函数的重写
virtual void Driver()
{
cout << "Benz-豪华舒适" << endl;
}
};
int main()
{
Car c;
BMW b;
Benz bz;
return 0;
}
上面我们在BMW类中没有实现对Car类中虚函数的重写，在Benz类中实现了对Car类中虚函数的重写，在main函数中我们分别实例化了三个类，查看错误列表的信息，我们发现Car和BWM类都因为是抽象类而无法被实例化，而Benz类中实现了虚函数的重写，所以可以正常实例化。
class Car
{
public:
virtual void Driver() = 0;
};
class BMW :public Car
{
public:
//实现了对虚函数的重写
virtual void Driver()
{
cout << "操纵-好开" << endl;
}
};
class Benz :public Car
{
public:
//实现了对虚函数的重写
virtual void Driver()
{
cout << "Benz-豪华舒适" << endl;
}
};
int main()
{
Car* ptr = new BMW;
ptr->Driver();
ptr = new Benz;
ptr->Driver();
return 0;
}
这里我们可以看到进行重写之后就可以正常实例化对象了。
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
这里我们先看一道常考的笔试题:sizeof(Base)是多少?
可能有很多人的答案是4bytes，但是正确的答案是8bytes。除了_b成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个和平台有关系)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
那么派生类中这个表放了些什么呢?基类和派生类中的虚表有什么区别，以及其他的细节之处。
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;
}
通过观察两个虚表中存储的函数的地址和函数名称，我们可以看到一些问题。
在父类与子类中都会有一张虚表，虚函数Func1在子类中进行了重写，所以地址发生了变化，所以这里也就很好的证明了多态行为产生的原因，当我们用父类、子类对象调用同一个已经进行重写过的虚函数时，底层其实调用的是不同的函数，所以行为也就不同了。
虚函数Func2在子类中没有进行重写，所以它的地址没有发生变化，父类和子类调用Func2函数的时候，调用的是同一个函数。
函数Func3函数根本就不是虚函数，所以也就不会进入虚表。
总结:
这里我们先写一个具有多继承关系的代码。
class Base1
{
public:
virtual void func1() { cout << "Base1::func1" << endl; }
virtual void func2() { cout << "Base1::func2" << endl; }
private:
int _b1 = 1;
};
class Base2
{
public:
//func1,func2实现重写
virtual void func1() { cout << "Base2::func1" << endl; }
virtual void func2() { cout << "Base2::func2" << endl; }
private:
int _b2 = 2;
};
class Derive :public Base1, public Base2
{
public:
//func1实现重写，func3为Derive中自身定义的虚函数
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
private:
int _d = 3;
};
多继承中的虚表是什么样子的呢?
在上面的这两个虚表中我们只看到了func1和func2两个虚函数，那么Derive自己定义的虚函数去哪里了呢，其实这个虚函数被隐藏了，只通过监视窗口是无法看到的，所以我来带大家打印一下这个两个虚函数表中所存的虚函数的地址。
首先我们先来实现一个专门打印虚表地址的函数。(很考验大家的C语言的功底)
typedef void(*VFPTR)(); //void(*)()是函数指针的类型，这里我们将其typedef为VFPTR，方便后面看
void PrintVFTable(VFPTR* table)//定义table函数指针数组存储函数指针
{
cout << "虚表地址" << table << endl;
//因为vs下虚表的最后一个位置是nullptr，所以我们以它作为循环结束条件
for (size_t i = 0; table[i] != nullptr; i++)
{
printf("vft[%d]->%p", i, table[i]);
VFPTR pf = table[i]; //定义一个指针接受函数指针的数值
pf();//以这种形式就可以调用相对应的函数
}
cout << endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVFTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVFTable(vTableb2);
return 0;
}
通过输出的结果，我们可以看到Derive类中自己的虚函数是被放到了Base1中的虚表中。
class Base1
{
public:
virtual void func1() { cout << "Base1::func1" << endl; }
virtual void func2() { cout << "Base1::func2" << endl; }
private:
int _b1 = 1;
};
class Base2
{
public:
//func1,func2实现重写
virtual void func1() { cout << "Base2::func1" << endl; }
virtual void func2() { cout << "Base2::func2" << endl; }
private:
int _b2 = 2;
};
class Derive :public Base1, public Base2
{
public:
//func1实现重写，func3为Derive中自身定义的虚函数
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
private:
int _d = 3;
};
typedef void(*VFPTR)(); //void(*)()是函数指针的类型，这里我们将其typedef为VFPTR，方便后面看
void PrintVFTable(VFPTR* table)//定义table函数指针数组存储函数指针
{
cout << "虚表地址" << table << endl;
//因为vs下虚表的最后一个位置是nullptr，所以我们以它作为循环结束条件
for (size_t i = 0; table[i] != nullptr; i++)
{
printf("第%d个虚表地址:->%p,->", i, table[i]);
VFPTR pf = table[i]; //定义一个指针接受函数指针的数值
pf();//以这种形式就可以调用相对应的函数
}
cout << endl;
}
void Func(Base1& b)
{
b.func1();
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVFTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVFTable(vTableb2);
printf("%p\n", &Derive::func1);
d.func1();
Base1* ptr1 = &d;
ptr1->func1();
Base2* ptr2 = &d;
ptr2->func1();
return 0;
}
实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。
1.inline函数可以是虚函数么？
答:可以，但是inline只是一个建议，当一个函数是虚函数以后，多态调用中，inline失效了。
2.static函数可以是虚函数么?
答:没有this指针，直接可以使用A::func2(),虚函数是为了实现多态，多态都是运行时去虚表找(运行时决议)，static成员函数都是在编译时决议，他是virtual函数没有价值
3.构造函数可以是虚函数么
答:不可以，virtual函数是为了实现多态，运行时去虚表中找对应虚函数进行调用，对象中虚表指针都是构造函数初始化列表阶段才初始化的(也就是说这个时候该对象已经初始化好了)，所以构造函数虚函数是没有意义的。
4.析构函数可以是虚函数吗?
答:可以，建议基类的析构函数定义成虚函数。
5.拷贝构造和operator=可以是虚函数么？
答:拷贝构造不可以，拷贝构造也是构造函数，参考上面的构造函数即可
operator=可以，但是没有什么实际价值
6.对象访问普通函数更快还是虚函数更快?
答:首先如果是普通对象，是一样快的。
如果是指针对象或者引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
7.虚函数表是在什么阶段生成的，存在哪里？
答:编译阶段就生成好的，存在代码段(常量区)
注意:
虚函数表是构造函数初始化阶段生成的，存在对象里面这句话是错误的，下面的才是对的。
构造函数初始化列表阶段初始化的是虚函数表指针，对象中存的也是虚函数表指针。
下面我们来证明一下虚表是存在什么位置的。
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student :public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
int main()
{
Person p;
Student s;
printf("虚表:%p\n", *((int*)&s));
static int x = 0;
printf("static变量:%p\n", &x);
const char* ptr = "hello world";
printf("常量:%p\n", ptr);
int y = 0;
printf("局部变量:%p\n", &y);
printf("new变量:%p\n", new int);
return 0;
}
看了这么长的一篇文章，总要有重点，其实我们后面讲的底层的东西大家只需要了解就可以了，最重要的还是:
1.语法:
1.重写的概念及条件
2.多态的概念及条件
2.原理:
1.虚表是什么
2.多态的原理是什么
3.普通调用，编译时决议和多态调用，运行时决议区别是什么
关于多态的内容我们已经讲解完毕，可以看到其中的细节是一点也不比继承中的少，而且这两部分都是C++中的重点，翻过这两座大山后面关于纯理论的知识也就不是很多了，上面最后面所说的相关知识点是一定要掌握的，最后如果文章有错误的地方请大家指出，我一定会改正，如果感觉知识点对你有用的话，就给波三连吧。