【C++】多态详细讲解

本篇来聊聊C++面向对象的第三大特性-多态。

1.多态的概念

多态通俗来说就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)。

编译时多态：主要就是我们前⾯讲的函数重载和函数模板，他们传不同类型的参数就可以调⽤不同的函数，通过参数不同达到多种形态。

运⾏时多态：具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种形态。

我们重点要说的是运行时多态。运行时多态举个例子：买票的行为，学生买票是学生票，普通人买票是全价票，军人买票又是优先票...这就是买票行为的多种形态。

2.多态的定义及实现

2.1 多态的构成条件

多态是⼀个 继承关系下 的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了

Adult 。Adult 对象买票全价，Student对象优惠买票。

实现多态还有 两个必须 重要条件：

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

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

2.2 虚函数

类成员函数前⾯加 virtual 修饰，那么这个成员函数被称为虚函数。 （注意⾮成员函数不能加virtual修饰）

class Adult  //基类
{ 
public:
	virtual void BuyTicket()
	{
		cout << "全价票" << endl;
	}
};

virtual在继承里也遇到过，在继承里出现是为了解决菱形继承问题，跟多态里virtual意义不同。

2.3 虚函数的重写/覆盖

派⽣类中有⼀个跟基类 完全相同 （返回值类型、函数名字、参数列表的类型完全相同）的虚函数，称派⽣类的虚函数重写了基类的虚函数。

class Student : public Adult //派生类
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票" << endl;
	}
};

注意：在重写基类虚函数时， 派⽣类的 虚函数在 不加virtual 关键字时，也 可以构成重写 (因为继承 后基类的虚函数被继承下来了在派⽣类依旧保持虚函数属性)， 但是该种写法不是很规范 ，不建议这样 使⽤。

2.3.1 多态的实例

基类和派生类还是前面的Adult和Student，现在这里有个Ticket函数。

void Ticket(Adult* pa) //基类的指针
{
	pa->BuyTicket();
}

前面说过，多态的第一个条件，必须是基类的指针或者引⽤调⽤，这里的pa满足；第二个条件，被调用函数必须是虚函数而且进行了虚函数的重写/覆盖，这里的BuyTicket函数满足条件。

int main()
{
	Adult a;   //基类对象
	Student s; //派生类对象
	Ticket(&a);
	Ticket(&s);

	return 0;
}

传不同的对象过去，得到的结果不同。

成功构成了多态。

引用的写法如下。

void Ticket(Adult& pa) //基类的引用
{
	pa.BuyTicket();
}

int main()
{
	Adult a;   //基类对象
	Student s; //派生类对象
	Ticket(a);
	Ticket(s);

	return 0;
}

再加一个派生类也是可以的。

class Soldier : public Adult //派生类
{
public:
	virtual void BuyTicket()
	{
		cout << "军人票" << endl;
	}
};

然后只用Student和Soldier这两个派生类。

int main()
{
	Student st; //派生类对象
	Soldier so; //派生类对象
	Ticket(st);
	Ticket(so);

	return 0;
}

2.3.2 对实例进一步解释

1.为什么一定是基类的指针或引用？在继承中我们说过派生类和基类的切片/切割问题，参数类型是基类可以保证实参传基类的对象也可以，传派生类的对象也可以。如果是派生类的指针或引用，基类对象根本传不过去。

2.对于Ticket函数的参数列表，按照我们在继承中的说法，不管传什么过去，调用的都是Adult的成员函数，因为此时pa是由参数类型决定的，与传过来的对象无关，但是，在多态中，pa与自己的类型无关，只与传过来的对象有关，指向谁，调用谁。

3.构成多态的两个条件必须都满足。

如果不满足其中一个条件，比如基类没有虚函数。

class Adult //基类
{
public:
	void BuyTicket() //没有虚函数
	{
		cout << "全价票" << endl;
	}
};

class Student : public Adult //派生类
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票" << endl;
	}
};

void Ticket(Adult* pa) //基类的指针或引用
{
	pa->BuyTicket();
}

int main()
{
	Adult a;   //基类对象
	Student s; //派生类对象
	Ticket(&a);
	Ticket(&s);

	return 0;
}

此时不构成多态，pa就走继承那套逻辑，不管传什么都是调用基类的。

如果都是虚函数并且进行了虚函数的重写/覆盖，但是Ticket参数类型不是基类的指针或引用，依旧是不构成多态的。

class Adult //基类
{
public:
	virtual void BuyTicket()
	{
		cout << "全价票" << endl;
	}
};

class Student : public Adult //派生类
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票" << endl;
	}
};

void Ticket(Adult pa) //不是基类的指针或引用
{
	pa.BuyTicket();
}

int main()
{
	Adult a;   //基类对象
	Student s; //派生类对象
	Ticket(a);
	Ticket(s);

	return 0;
}

所以一定要同时满足构成多态的两个条件。

2.3.3 多态的经典例题

下面程序运行的结果是什么？

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()
{
	B* p = new B;
	p->test();
	return 0;
}

答案：B -> 1

有两个类，A是基类，B是派生类。A和B里有返回值、函数名、参数类型都相同的函数func，虽然在派生类B里面没有加virtual，在这里依然构成虚函数的重写（原因前面说过）。

p是B类的指针，因为B继承了A，所以B类的指针p可以调用test函数。

在类里，成员函数都有隐含的this指针，这个this指针类型是A* 不是B*，虽然继承到B来了，但这只是一种说法，并不是真的把A里的内容全拷贝一份给B，所以A继承下来成员函数this指针类型依然是A*。

所以，调用func函数的就是基类的指针。

而func又构成虚函数的重写，所以这里同时满足了构成多态的两个条件。既然构成了多态，p指向派生类B，所以func应该是B类重写的func。

但是虚函数的重写只会重写函数体部分，重写后的样子如下。

所以结果是 B -> 1 。

2.3.4 协变

派⽣类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引⽤，派⽣类虚函数返回派⽣类对象的指针或者引⽤时，称为协变。协变的实际意义并不⼤，所以我们了解⼀下即可。

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

void Func(Person* ptr)
{
    ptr->BuyTicket();
}

int main()
{
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

返回类型也可以是自己类型的指针或引用。

2.3.5 析构函数的重写

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

下⾯的代码我们可以看到，如果~A()，不加virtual，那么delete p2时只调⽤的A的析构函数，没有调⽤B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。

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

2.3.6 override 和 final关键字

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

class Car 
{
public:
	virtual void Dirve()
	{}
};

class Benz :public Car 
{
public:
	virtual void Drive() override 
    { 
        cout << "Benz" << endl; 
    }
};

int main()
{
	return 0;
}

如果不加override这个代码是检查不出错误的。

class Car
{
public:
	virtual void Drive() final  //不能被重写
    {}
};
class Benz :public Car
{
public:
	virtual void Drive() 
    { 
        cout << "Benz" << endl; 
    }
};
int main()
{
	return 0;
}

不想成员函数被重写，就加上final。

2.4 重载/重写/隐藏的对⽐

3.纯虚函数和抽象类

在虚函数的后⾯写上 =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;
}

4.多态的原理

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

答案：D.12

类的大小如何计算，在【C++】类和对象（上）：初识类和对象中的 2.2 对象大小 有详细解释。

按照计算对象大小的规则，这里的结果应该是8，但为什么是12呢？因为除了_b和_ch成员，还多⼀个_vfptr放在对象的前⾯(注意有些平台可能会放到对象的最后⾯，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针（简称虚表指针）。

vf就是virtual function。这个指针在32位程序下大小为4，所以按照内存对齐规则，大小为12.

⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。这里的表其实就是一个数组，虚函数表也就是一个函数指针数组，虚函数表指针就是指向这个数组的指针。

比如我们现在再加一个虚函数，这个_vfptr就会多一个内容。

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Func2()" << endl;
	}
	void Func3()  //不是虚函数
	{
		cout << "Func3()" << endl;
	}
protected:
	int _b = 1;
	char _ch = 'x';
};

这里只会存放虚函数的指针，不是虚函数不会放在里面，func3就不再这个里面。

4.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)
{
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Soldier sr;
	Func(&ps);
	Func(&st);
	Func(&sr);
	return 0;
}

4.2.1 从理论上分析

有ps、st、sr三个对象，就有三个虚函数表，这三个虚表里存放着自己的虚函数。

多态中Func函数应该是指向谁调用谁。

从内存角度，这里的ptr“看到的”都是父类，因为传子类过去会切片。

在满足多态的条件下，运行时编译器会找_vfptr这个指针，然后通过这个指针去对应的虚函数表里去找虚函数的地址。不管传的ptr类型是什么，与类型无关，只与指向的对象有关。

4.2.2 从汇编角度观察

满足多态条件下的汇编，最终调的是 call eax 。

不满足多态时，把前面的代码父类中的virtual删除，就不满足了。

class Person  //父类
{
public:
	void BuyTicket() { cout << "买票-全价" << endl; }
private:
	string _name;
};

来看一下汇编。

不管传的ptr是什么，与对象无关，调用的都是父类的函数。

4.3 静态绑定与动态绑定

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

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

// ptr是指针+BuyTicket是虚函数满⾜多态条件。
// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址

	ptr->BuyTicket();
00CD3C72  mov         eax,dword ptr [ptr]  
00CD3C75  mov         edx,dword ptr [eax]  
00CD3C77  mov         esi,esp  
00CD3C79  mov         ecx,dword ptr [ptr]  
00CD3C7C  mov         eax,dword ptr [edx]  
00CD3C7E  call        eax

// BuyTicket不是虚函数，不满⾜多态条件。
// 这⾥就是静态绑定，编译器直接确定调⽤函数地址

	ptr->BuyTicket();
00603C72  mov         ecx,dword ptr [ptr]  
00603C75  call        Person::BuyTicket (06015FFh)

5.虚函数表更深入的讲解

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

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

派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。

派⽣类的虚函数表中包含， (1)基类的虚函数地址，(2)派⽣类重写的虚函数地址完成覆盖，（3）派⽣类⾃⼰的虚函数地址三个部分。

虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的)。

虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，vs下是存在代码段(常量区)

虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址⼜存到了虚表中。

本次分享见到这里，我们下篇见~