C++——多态

目录

1.多态的概念

2. 多态的定义及实现

​编辑

3.抽象类

4.多态的原理

1.虚函数表指针

2.动态绑定与静态绑定

3.虚函数表

---

1.多态的概念

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

2. 多态的定义及实现

1. 多态的构成条件

1. 1. 多态是⼀个继承关系下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了
      Person。Person对象买票全价，Student对象优惠买票。
2. 1. 实现多态还有两个必须重要条件：

要实现多态效果，第⼀必须是⽗类的指针或引⽤，因为只有⽗类的指针或引⽤才能既指向⽗⼦
类对象；第⼆⼦类必须对⽗类的虚函数重写/覆盖，重写或者覆盖了，⽗⼦类才能有不同的函数，多态
的不同形态效果才能达到。

1. 1. 1. • 必须指针或者引⽤调⽤虚函数
         • 被调⽤的函数必须是虚函数。

1. 虚函数

1. 1. 虚函数的定义

class Person
{ p
ublic:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

1. 1. 1. 类成员函数（友元函数不是成员函数不能设置成为虚函数）前⾯=加virtual修饰，那么这个成员函数被称为虚函数。注意==⾮成员函数不能加virtual修
         饰==。

1. 1. 1. 虚函数有this指针

1. 1. 虚函数的重写/覆盖

1. 1. 1. 虚函数的重写/覆盖：⼦类中有⼀个跟⽗类完全相同的虚函数(即⼦类虚函数与⽗类虚函数的返回值类
         型、函数名字、参数列表完全相同)，称⼦类的虚函数重写了⽗类的虚函数。

注意：在重写⽗类虚函数时，⼦类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后
⽗类的虚函数被继承下来了在⼦类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使
⽤，不过在考试选择题中，经常会故意买这个坑，让你判断是否构成多态。

做题总结：在C++中，静态成员函数（包括静态虚成员函数）不拥有 this 指针。这是因为静态成员函数属于类本身，而不是类的某个具体对象。因此，它们无法访问非静态成员变量或调用非静态成员函数，因为这些都需要通过 this 指针来引用特定的对象实例。

class Person {
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};class Student : public Person 
{
public:virtual void BuyTicket() { cout << "买票-打折" << endl; }
};void Func(Person* ptr)
{// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。ptr->BuyTicket();
} int main()
{Person ps;Student st;Func(&ps);Func(&st);return 0;
}

class Animal
{ 
public:virtual void talk() const{}
};class Dog : public Animal
{ 
public:virtual void talk() const{std::cout << "汪汪" << std::endl;}
};class Cat : public Animal
{ 
public:virtual void talk() const{std::cout << "(>^ω^<)喵" << std::endl;}	
};void letsHear(const Animal& animal)
{animal.talk();
} int main()
{Cat cat;Dog dog;letsHear(cat);letsHear(dog);return 0;
}

1. 1. 多态场景的⼀个选择题 选择( B )

1. 1. 1. 因为继承并不是继承真的从子类拷贝一份成员函数到子类，所以虽然调用的test()函数，但是调用的函数指针还是父类的，然后因为test中有func函数，调用的是子类的func函数（这里理解的并不是很透彻）
2. 1. 1. 重写：父类的声明部分+子类的实现的函数题部分，所以缺省值在父类声明也用到的是父类的

1. 1. 析构函数的重写

class A
{ 
public:virtual ~A(){cout << "~A()" << endl;}
};class B : public A {
public:~B(){cout << "~B()->delete:"<<_p<< endl;delete _p;}
protected:int* _p = new int[10];
};// 只有⼦类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构
//成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。int main()
{A* p1 = new A;A* p2 = new B;delete p1;delete p2;return 0;
}

1. 1. 1. ⽗类的析构函数为虚函数，此时⼦类析构函数只要定义，⽆论是否加virtual关键字，都与⽗类的析构
         函数构成重写，虽然⽗类与⼦类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函
         数的名称做了特殊处理，编译后析构函数的名称统⼀处理成destructor，所以⽗类的析构函数加了
         vialtual修饰，⼦类的析构函数就构成重写

1. 1. 1. 下⾯的代码我们可以看到，如果~A()，不加virtual，那么deletep2时只调⽤的A的析构函数，没有调⽤
         B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。
         注意：这个问题⾯试中经常考察，⼤家⼀定要结合类似下⾯的样例才能讲清楚，为什么⽗类中的析构
         函数建议设计为虚函数。

1. 1. override和final关键字

class Car {
public:virtual void Dirve(){}
};class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何⽗类⽅法
};int main()
{return 0;
}

class Car
{
public :virtual void Drive() final {}
};
class Benz :public Car
{
public :// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{return 0;
}

1. 1. 1. C++对函数重写的要求⽐较严格，但是有些情况下由于疏忽，⽐如函数名写错参数写
         错等导致⽆法构成重载，⽽这种错误在编译期间是不会报出的，只有在程序运⾏时没有得到预期结果
         才来debug会得不偿失，因此C++11提供了override，可以帮助⽤⼾检测是否重写。如果我们不想让⼦
         类重写这个虚函数，那么可以⽤final去修饰

1. 1. 重载、重写/覆盖、隐藏的对⽐

3.抽象类

1. 在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现，只要声明即可。包含纯
   虚函数的类叫做抽象类，抽象类不能实例化出对象，如果⼦类继承后不重写纯虚函数，那么⼦类也是
   抽象类。纯虚函数某种程度上强制了⼦类重写虚函数，因为不重写实例化不出对象。

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;}
};
int main()
{// 编译报错：error C2259: “Car”: ⽆法实例化抽象类Car car;Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();return 0;
}

4.多态的原理

1.虚函数表指针

1. 下⾯编译为32位程序的运⾏结果是什么（）

A.编译报错 B.运⾏报错 C.8 D.12

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;
}

上⾯题⽬运⾏结果12bytes，除了_b和_ch成员，还多⼀个__vfptr放在对象的前⾯(注意有些平台可能
会放到对象的最后⾯，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代
表function)。⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要
被放到这个类对象的虚函数表中，虚函数表也简称虚表。

1. 从底层的⻆度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调⽤Person::BuyTicket，ptr指向Student对象调⽤Student::BuyTicket的呢？通过下图我们可以看到，满⾜多态条件后，底层不再是编译时通过调⽤对象确定函数的地址，⽽是运⾏时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引⽤指向⽗类就调⽤⽗类的虚函数，指向⼦类就调⽤⼦类对应的虚函数。第⼀张图，ptr指向的Person对象，调⽤的是Person的虚函数；第⼆张图，ptr指向的Student对象， 调用的是Student的虚函数

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* ptr)
{// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。ptr->BuyTicket();
} int main()
{// 其次多态不仅仅发⽣在⽗⼦类对象之间，多个⼦类继承⽗类，重写虚函数后// 多态也会发⽣在多个⼦类之间。Person ps;Student st;Soldier sr;Func(&ps);Func(&st);Func(&sr);return 0;
}

2.动态绑定与静态绑定

1. 对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤
   函数的地址，叫做静态绑定。

1. 满⾜多态条件的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数
   的地址，也就做动态绑定。

// ptr是指针+BuyTicket是虚函数满⾜多态条件。
// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址
ptr->BuyTicket();
00EF2001 mov eax,dword ptr [ptr]
00EF2004 mov edx,dword ptr [eax]
00EF2006 mov esi,esp
00EF2008 mov ecx,dword ptr [ptr]
00EF200B mov eax,dword ptr [edx]
00EF200D call eax
// BuyTicket不是虚函数，不满⾜多态条件。
// 这⾥就是静态绑定，编译器直接确定调⽤函数地址
ptr->BuyTicket();
00EA2C91 mov ecx,dword ptr [ptr]
00EA2C94 call Student::Student (0EA153Ch)

3.虚函数表

⽗类对象的虚函数表中存放⽗类所有虚函数的地址。
• ⼦类由两部分构成，继承下来的⽗类和⾃⼰的成员，⼀般情况下，继承下来的⽗类中有虚函数表指
针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的⽗类部分虚函数表指针和⽗类
对象的虚函数表指针不是同⼀个，就像⽗类对象的成员和⼦类对象中的⽗类对象成员也独⽴的。
• ==⼦类中重写的⽗类的虚函数，⼦类的虚函数表中对应的虚函数就会被覆盖成⼦类重写的虚函数地
址==。
• ⼦类的虚函数表中包含，⽗类的虚函数地址，⼦类重写的虚函数地址，⼦类⾃⼰的虚函数地址三个
部分

虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标
记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000
标记，g++系列编译不会放)
• 虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函
数的地址⼜存到了虚表中。
• 虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码可以
对⽐验证⼀下。vs下是存在代码段(常量区)

class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
};
class Derive : public Base
{
public :// 重写⽗类的func1virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func1" << endl; }void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};int mian()
{Base b;Derive d;return 0;
}

int main()
{int i = 0;static int j = 1;int* p1 = new int;const char* p2 = "xxxxxxxx";printf("栈:%p\n", &i);printf("静态区:%p\n", &j);printf("堆:%p\n", p1);printf("常量区:%p\n", p2);Base b;Derive d;Base* p3 = &b;Derive* p4 = &d;printf("Person虚表地址:%p\n", *(int*)p3);printf("Student虚表地址:%p\n", *(int*)p4);printf("虚函数地址:%p\n", &Base::func1);printf("普通函数地址:%p\n", &Base::func5);return 0;
} 运⾏结果：
栈:010FF954
静态区:0071D000
堆:0126D740
常量区:0071ABA4
Person虚表地址:0071AB44
Student虚表地址:0071AB84
虚函数地址:00711488
普通函数地址:007114BF