多态（c++）

标签：函数 基类 多态 c++ virtual 派生类 重写

一、概念

多态分为编译时多态（静态多态）和运行时多态（动态多态），函数重载和函数模板就是编译时多态，它们传不同的类型的参数就可以调用不同的函数，通过参数不同达到多种形态，因为它们实参传给形参的参数匹配是在编译时完成的，所以叫编译时多态

运行时多态，在完成某个行为（函数），可以传不同的对象就会完成不同的行为，达到多种形态

二、多态的构成条件

1、必须是指针或者引用调用虚函数

2、被调用的函数必须是虚函数

要实现多态的效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能够既指向派生类对象又能指向基类的对象。

派生类必须对基类的虚函数重写/覆盖，只有这样才能有不同的函数，多态的效果才能达到

 三、虚函数的重写/覆盖

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

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

class Person {
public:
//类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。
//注意虚函数和虚继承两者没有关系，且⾮成员函数不能加virtual修饰。
	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;
}

（代码1） 

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

 （代码2）

四、多态场景下的一个典型题目

五、协变

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

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

（代码3） 

六、析构函数的重写

基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加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()
{
	//如果它们的析构函数没有构成多态，那么在delete p2时
	//只是将p2这个地址清理了，而它指向的空间并没有的到释放
	//在构成重写的情况下执行delete p2时，因为构成多态
	//所以在p2指向父类就调用父类的析构函数，指向子类就调用子类析构函数
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;
	return 0;
}

（代码4）

七、override和final关键字

C++11提供了override，可以帮助用户检测是否重写。如果我们不想让派 ⽣类重写这个虚函数，那么可以⽤final去修饰。

八、重载、重写和隐藏的对比

 

九、纯虚函数和抽象类

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

（代码5）

十、多态的原理

虚函数表指针

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

 （代码6）

上面的代码sizeof（b）的结果就是12，因为除了_b和_ch成员外，还多了一个__vfptr放在对象的前面，对象中这个指针我们叫做虚函数表指针（是一个函数指针数组）。一个含有虚函数的类中至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中。

多态是如何实现的 

 回到代码1，在满足多态后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数

动态绑定与静态绑定 

对不满足多态条件（指针或者引用+调用函数）的函数调用是在编译时绑定，也就是编译时确定屌用函数的地址，叫津泰绑定

满足多态条件的函数调用是在运行时绑定的，也就是在运行时到指定对象的虚函数表中找到调用函数的地址，叫做动态绑定

虚函数表

1、基类对象的虚函数表中存放基类所有的地址。

2、派生类由两部分构成：继承下来的基类和自己的成员。一般情况下继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的是这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也独立的。

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

4、派生类的虚函数表中包含：基类的虚函数地址、派生类重写的虚函数地址、派生类自己的虚函数地址三个部分，但是派生类自己的虚函数地址在编译器调试中看不到，但是它是实际存在的，可以通过内存窗口查看。

5、虚函数表本质是一个虚函数指针的指针数组，一般情况下数组的最后面放了一个0X00000000标记，但是g++编译不会。

6、虚函数和普通函数一样的，编译好后是一条指令，都是存在代码段的，只是虚函数的地址又存到了虚表中。

7、虚函数表存在哪？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:
	// 重写基类的func1
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func1" << endl; }
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};
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;
   //函数的前四个字节就是地址，把它转换成int*就可以查看它的地址
	printf("Person虚表地址:%p\n", *(int*)p3);
	printf("Student虚表地址:%p\n", *(int*)p4);
   //c++规定取成员函数地址时要加&
	printf("虚函数地址:%p\n", &Base::func1);
	printf("普通函数地址:%p\n", &Base::func5);

	Base b;
	Derive d;
	return 0;
}

（代码7）

运行结果：

运⾏结果： 栈 : 010F F954 静态区 : 0071 D000 堆 : 0126 D740 常量区 : 0071 ABA4 Person 虚表地址 : 0071 AB44 Student 虚表地址 : 0071 AB84 虚函数地址 : 00711488 普通函数地址 : 007114B F

标签：函数,基类,多态,c++,virtual,派生类,重写
From： https://blog.csdn.net/qq_75271671/article/details/143633726