【C++修仙录03】进阶篇：多态

class Animal
{
public:
	virtual void talk()
	{

	}
};
class Cat:public Animal
{
public:
	virtual void talk()
	{
		cout << "关注塔菲喵" << endl;
	}
};
class Dog:public Animal
{
public:
	virtual void talk()
	{
		cout << "汪汪汪" << endl;
	}
};
void func(Animal*a)
{
	a->talk();
}
int main()
{
	Dog d;
	func(&d);

	Cat c;
	func(&c);
	return 0;
}

多态的定义及实现

多态的构成条件

多态是一个继承关系下的类对象，去调用同一函数，产生不同行为。例如Dog 继承了Animal,Dog对象汪汪叫

实现多态的2个重要条件

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

只有基类的指针/引用才能既指向基类对象又指向派生类

派生类必须对基类的虚函数完成重写/覆盖，重写或者覆盖了，基类和派派生类之间才能有不同的函数，多态的不同形态效果才能达到。

虚函数

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

cpp 复制代码

class Animal
{
public:
	 virtual void talk()
	{
		cout << "1" << endl;
	}
};

class Dog:public Animal
{
public:
	virtual void talk()
	{
		cout << "汪汪汪" << endl;
	}
};

虚函数的重写/覆盖

基类的成员函数必须加virtual

派生类的虚函数与基类的虚函数满足返回类型相同 ，参数类型相同 ，函数名相同才能构成重写

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)

但是该种写法不是很规范，不建议这样使用，不过在考试选择题中，经常会故意埋这个坑，让你判断是否构成多态。

上图就是实现了多态

我们根据上图代码，再次总结多态如何实现

1.必须是基类的指针或引用

void func(Animal * a)

{

a->talk();

}

2.必须调用的是虚函数，并且完成了虚函数的重写（基类的虚函数与派生类的虚函数函数名相同，参数相同，返回类型相同）

class Animal

{

public:

virtual void talk()

{

cout << "1" << endl;

}

};

class Cat:public Animal

{

public:

virtual void talk()

{

cout << "关注塔菲喵" << endl;

}

};
void func(Animal*a)

{

a->talk(); //talk() 是虚函数

}

多态场景的一个选择题

以下程序输出的结果是？

A:A->0 B:B->1 C:A->1 D:B->0 E:编译出错 F:以上都不正确

cpp 复制代码

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

首先拿到这道题，判断它是否实现了多态

基类的虚函数是 func，派生类的虚函数也是 func 他们函数名相同，参数类型相同，返回类型相同，构成重写条件。

我们继续检查调用虚函数时，是不是是基类的引用或指针？

调用test() 函数，由于这个函数在基类里面。test()函数还可以换种写法

cpp 复制代码

virtual void test()
{ 
  this->func();
}

this 是基类的指针，符合构成多态的第一个条件

我们看到，我们的p 是指向B 的对象，并且实现了多态，那么打印的应该是 B->

到这里，大家可能觉得直接选D ，那这样就掉入了陷阱

我们的派生类重写虚函数，是以基类的虚函数为模板，改变虚函数里面内容，所以 val 的缺省值是1

答案是" B->1 "

虚函数重写的一些其他问题

析构函数的重写（非常重要）

析构函数在我们继承章节讲到基类和派生类的析构函数在编译后析构函数的名称统⼀处理成destructor，当时我们并没有将原理，现在我们学习了多态，就可以解释为什么要这么做了

请看下面的代码

cpp 复制代码

class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	virtual ~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};

int main()
{
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;
	return 0;
}

这个代码实现了多态，在delete 对象时，是看指针指向的对象，就析构哪个对象

我们运行这段代码，得到正常结果

如果我们不形成多态(去掉基类的 virtual )，又会怎么样呢？

cpp 复制代码

class A
{
public:
	 ~A()
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};

int main()
{
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;
	return 0;
}

那么delete p2时只调用的A的析构函数，没有调用B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。

在日常中，我们不会在基类刻意的去掉virtual ，就是为了避免不调用派生类的析构而导致的内存泄漏，

我们把基类的析构和派生类的析构全部变为 destructor，基类和派生类的析构函数前加virtual ，就是为了能让派生类的虚函数重写，实现多态，从而避免像上图代码出现的内存泄漏情况

是现有了处理这样的情况，使得编译器处理基类和派生类析构函数名统一，后来才有继承情况下出现隐藏

协变

override和final关键字

C++对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数

写错等导致无法构成重写，而这种错误在编译期间是不会报出的

cpp 复制代码

class Car 
{
public:
	virtual void car()
	{

	}
};
class Benz :public Car
{
public:
	virtual void car()
	{
		cout << "霸气" << endl;
	}
};
class Bm :public Car
{
public:
	virtual void ca() //
	{
		cout << "舒适" << endl;
	}
};
void func(Car*c)
{
	c->car();
}
int main()
{
	Bm b;
	func(&b);


	Benz z;
	func(&z);
	return 0;
}

看这里的错误，Bm 类中的虚函数的函数名错了，编译器也没有检查出来

但如果我们在这个虚函数后面加上override 编译器就可以检查出来

如果我们不想让派生类重写这个虚函数，那么可以用 final去修饰

cpp 复制代码

class Car final
{
public:
	virtual void car()
	{

	}
};
class Benz :public Car
{
public:
	virtual void car()
	{
		cout << "霸气" << endl;
	}
};
class Bm :public Car
{
public:
	virtual void car() override
	{
		cout << "舒适" << endl;
	}
};
void func(Car*c)
{
	c->car();
}
int main()
{
	Bm b;
	func(&b);


	Benz z;
	func(&z);
	return 0;
}

用final 修饰后，不可用派生类重写虚函数

重载/重写/隐藏的对比

纯虚函数和抽象类

纯虚函数：在虚函数的后面写上=0 ，则构成纯虚函数（纯虚函数不需要定义实现，只需要声明就行）

cpp 复制代码

class Car
{
public:
	virtual void car() = 0;
};

抽象类：包含纯虚函数的类叫抽象类，抽象类不能实例化出对象，如果派生类不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种意义上强制了派生类重写虚函数，不写不能实例化出对象

抽象类不能实例化出对象

cpp 复制代码

class Car
{
public:
	virtual void car() = 0;
};
class Benz :public Car
{
public:
	virtual void car()
	{
		cout << "霸气" << endl;
	}
};
class Bm :public Car
{
public:
	virtual void car()
	{
		cout << "舒适" << endl;
	}
};
void func(Car*c)
{
	c->car();
}
int main()
{
	Car car;

	Bm b;
	func(&b);


	Benz z;
	func(&z);
	return 0;
}

完成对于纯虚函数的重写

多态的原理

虚函数表指针

请大家先看一段选择题

下面编译为32位程序的运行结果是什么（）

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

cpp 复制代码

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

int 占4字节，char 占1字节，最后内存对齐总共8字节，选C

如果你是这么想的那么你就掉在陷阱了

请看调试图，怎么还有一个_vfptr 指针？

算上这个指针，最终结果是12字节

一个类中的所有虚函数的地址都要放到类对象的虚函数表中，虚函数表也简称虚表

这个指针就是虚函数表指针，指向虚函数表

多态的原理

多态是如何实现的

我们通过调试这段代码来实现

cpp 复制代码

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 p;
	Func(&p);

	Student s;
	Func(&s);

	Soldier c;
	Func(&c);
	return 0;
}