了解和使用多态

多态的概念

多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)，这⾥我们重点讲运⾏时多态，编译时多态(静态多态)和运⾏时多态(动态多态)。编译时
多态(静态多态)主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。

运行时多态指的是，传不同的对象就会调用不同的方法，遇到多种形态。

多态的定义

#include<iostream>class person {
public:virtual void talk() {//被重写的函数需要virtual，构成虚函数。std::cout << "person talk" << std::endl;}
protected:int _num;};class student :public person {
public:virtual void talk() {//重写的函数，名字相同，参数相同，返回类型相同std::cout << "student talk" << std::endl;}
protected:int _id;};void fun(person*x) {//必须为基类的指针或者引用x->talk();
}
int main() {person d1;fun(&d1);student d2;fun(&d2);
}

从代码中的多态，我们可以知道构成多态的条件如下：

• 必须是基类的指针或者引⽤调⽤虚函数
• 被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖

说明：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向基类对象⼜指向派⽣类对象；
第⼆派⽣类必须对基类的虚函数完成重写/覆盖，重写或者覆盖了，基类和派⽣类之间才能有不同的函数，多态的不同形态效果才能达到。
实现多态要使用public 继承.

当基类不是虚函数的时候，不构成多态，调用只会调用person,如果不是指针，和引用也是如此.

1. 虚函数

虚函数就是在成员函数前面加virtual，一般在需要重写的函数前面加，非成员函数不能加。

2.虚函数的重写和覆盖

对于派生类函数重写或者覆盖基类函数（就是返回类型，函数名，参数要相同）。
派生类重写基类的函数前面可以不加virtual,因为它重写了，声明在基类，定义就派生类的这个函数。依旧保持了虚函数的特性。

协变

使用很少，了解一下

//协变
class A {};
class B :public A {};class person {
public:virtual A* talk() {//被重写的函数需要virtual，构成虚函数。std::cout << "person talk" << std::endl;return nullptr;}
protected:int _num;};class student :public person {
public:virtual B* talk() {//重写的函数，名字相同，参数相同，返回类型相同std::cout << "student talk" << std::endl;return nullptr;}
protected:int _id;};void fun(person* x) {//必须为基类的指针或者引用x->talk();
}int main() {person d1;fun(&d1);student d2;fun(&d2);
}

基类和子类重写的虚函数返回类型可以不一样，基类的虚函数返回类型必须是基类的指针或者引用，也可以是perosn派生类的虚函数返回类型必须是派生类的指针或者引用,也可以是student

多态的一道选择题

class A
{
public:virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }virtual void test() { func(); }
};
class B : public A
{
public:void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{B* p = new B;p->test();return 0;
}

分析：首先要判断，构不构成多态，B对象赋值给B类指针。对于继承，首先先出派生类找有没有test，再从基类找test().而基类的this->fun().恰好是基类的指针。fun函数是虚函数的重写或者覆盖。所以构成多态。因为对象传的是B的指针，所以调用B的函数。
注意：看到这里有人会选D，但是这个函数的重写，上面提过基类的虚函数构成声明，子类的虚函数构成定义，所以这个val 应该是1答案所以是B。

如果是注意，那么就不构成多态，因为没有基类的指针调用虚函数。答案就是D了

override和final

对于编译器编译的时候，如果函数没有重写，并不会检查出错误,协变也算重写
为了避免要忘记重写，所以c++11提供了override.

这个函数我们加上override必须重写，但是函数名不同而报错，如果没有就不会报错

final就与之相反
如果在基类虚函数后面加上final，就不能重写，重写了就会报错

纯虚函数和抽象类

在虚函数的后⾯写上 =0 ，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被
派⽣类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例
化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了
派⽣类重写虚函数，因为不重写实例化不出对象。

纯虚函数不能实列化出对象。

class car {
public:virtual void run() = 0;};
class ben :public car {
public:virtual void run() {std::cout << "品牌";}};int main() {//car e;ben de;
}

继承抽象类，如果不重写函数，就不能实列化出对象，必须要重写函数，才能实列化出对象。

多态的原理

1.虚函数表指针

class Base{public:virtual void Func1(){cout << "Func1()" << endl;}protected:int _b = 1;char _ch = 'x';};int main(){Base b;cout << sizeof(b) << endl;return 0;}

所以选D，因为为了实现多态的调用，虚函数要用虚函数表储存，然后虚函数表的指针存储类对象的内存里面，这里主要考察了内存对齐和虚函数表。

里面有个虚函数表，，只有虚函数才会放到这个虚表里面，普通函数不会，虚函数在里面构成指针数组，就是数组里面存储虚函数的指针。

2.多态的原理

多态调用函数的原理并不是在编译时，调用对象确定函数的地址，而是在运行时，通过基类的指针指向的对象，调用虚函数表指针，找到虚函数，从而在里面确实虚函数的地址。这样就实现了指向基类的指针指向基类的对象就调用基类的虚函数，指向派生类就调用派生类的虚函数。

即使继承下来，，虚函数表的地址不一样。重写的虚函数的地址也不一样

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:string _name;};class Student : public Person {public:virtual void BuyTicket() { cout << "买票-打折" << endl; }private:string _id;};class Soldier : public Person {public:virtual void BuyTicket() { cout << "买票-优先" << endl; }private:string _codename;};void Func(Person * ptr){// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。ptr->BuyTicket();}int main() {{// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后// 多态也会发⽣在多个派⽣类之间。Person ps;Student st;Soldier sr;Func(&ps);Func(&st);Func(&sr);return 0;}}

3. 动态绑定和静态绑定

不满足多态的条件就是静态绑定。静态绑定就是在编译时，就确定调用函数的地址。而动态绑定是在运行时，通过指针或者引用找到虚函数表，从而确定虚函数的地址。

4.虚函数表

• 基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }virtual void run() {cout << "跑";}
private:string _name;};class Student : public Person {public:virtual void BuyTicket() { cout << "买票-打折" << endl; }private:string _id;};

我们在基类多实现了一个虚函数，两个都是同一个类，所以总用一个虚函数表，而派生类的虚函数表和基类的虚函数表地址不一样，说明不是同一个表。由于继承下来，没有重写run，所以派生类的run地址跟基类一样。

• 派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表 指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基 类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴ 的。

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }virtual void run() {cout << "跑";}
private:string _name;};class Student : public Person {private:string _id;};

即使派生类没有 虚函数，也会继承虚函数表的指针，自己不用生成，但是两个虚函数表地址不同，说明不是同一个。

• 派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函 数地址。派⽣类的虚函数表中包含，(1)基类的虚函数地址，(2)派⽣类重写的虚函数地址完成覆盖，派⽣类 ⾃⼰的虚函数地址三个部分。

意思是重写基类的虚函数，派生类的虚函数表里面的虚函数地址就会变，如果重写，就是基类虚函数一样地址。自己的虚函数也会写入虚函数表。

vs下一般虚函数表存放在常量区。

今日的题:

对于static静态成员，只是属于类本身，不属于类对象，类对象不包括静态成员，所以A基类不包括静态成员。
B选项也是如此
C.子类对象继承了基类的私有成员，只是不能直接访问。
D，注意关键词，基类的静态成员一定不包含在子类对象中

2.由于粗心又错了

A子类的对象可以直接赋值给基类的指针。
B.不能父类赋值给子类
C跟B差不多，父类不能给子类。只要当父类的引用或者指针指向子类，才能将父类的指针或者引用给子类的引用或者指针
D对的，这是规则之一。

3.这是一道好题，注意是地址

这要结合继承基类与派生类的图

由于先继承的放在内存最前面，自己的成员放在最后面，这也是初始化的规则，所以p1,p3的地址一样，p2的地址不一样。

A被修饰的成员函数才叫虚函数
C定义可以不加virtual
D静态成员确实没有this指针，因为不属于具体的类对象。stactic 和virtual不能同时出现。

6

A 必须是父类的成员hanshu
B 通过父类的指针或者引用
C 在运行,编译时检查语法,这就是为什么叫运行时多态,运行时才调用.

重定义就是隐藏,重写和重定义是两码事.

7

重定义就是隐藏.
主要C选项,这里后半句出现矛盾,通过基类对象调用,这里就是不是多态了,多态是通过基类的引用或者指针调用虚函数.