c++多态（原理深入剖析+画图详细解释）

最新推荐文章于 2024-07-11 22:03:57 发布

gaogo12

最新推荐文章于 2024-07-11 22:03:57 发布

阅读量933

点赞数 14

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_64076540/article/details/134711305

版权

c++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

多态的概念

多态的概念，通俗来说就是多种形态。具体点就是完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子，同样是买票的动作，成年人去买可能就是全票，学生去买就是半价。
成年人 – 全价
学生 – 半价
这就是完成某个行为，不同的对象去完成会产生不同的状态。

多态的定义及实现

多态构成的条件

多态是在不同继承关系的对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

在继承中要构成多态还需要两个条件：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人 -- 全价" << endl;
	}
};

class Student : public Person
{
public: 
	virtual void BuyTicket()
	{
		cout << "学生 -- 半价" << endl;
	}
};


void Fun(Person& people)
{
	people.BuyTicket();
}


int main()
{
	Person ps;
	Student st;

	Fun(ps);
	Fun(st);
	return 0;
}

运行结果：
在这里插入图片描述
根据上述代码，我们再来理解一下构成多态的条件。

虚函数

被virtual修饰的函数叫作虚函数

虚函数的重写

虚函数的重写（覆盖）：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称子类的虚函数重写了基类的虚函数。

这里有一个小小的例外：子类的虚函数可以不加virtual关键字，这样写也是对的，可以理解为，子类在继承父类的时候也把父类的virtual继承下来了。
不过这样写不规范，不建议。

虚函数重写的两个例外：

1. 协变（基类与派生类虚函数返回值不同）
派生类重写基类虚函数时，与基类虚函数返回值类型不同。
基类虚函数返回基类的指针或者引用，派生类虚函数返回派生类的指针或者引用这种情况被称为协变。

class A
{
public:
	virtual A* fun()
	{
		cout << "A" << endl;
		return new A;
	}
};

class B : public A
{
public:
	virtual B* fun()
	{
		cout << "B" << endl;
		return new B;
	}
};

int main()
{
	B b;
	A& a = b;
	a.fun();

	A a1;
	a1.fun();
	return 0;
}

2. 析构函数的重写（基类与派生类析构函数名不同）
如果基类的析构函数是虚函数，那么派生类的析构函数只要定义，无论是否添加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。

这里虽然函数名不同，看似违背了多态的规则，其实不然，这里可以理解为编译器对析构函数的函数名做了特殊处理，编译后析构函数的名称统一处理为destructor。

class A
{
public:
	virtual ~A()
	{
		cout << "~A" << endl;
	}
};

class B : public A
{
public:
	virtual ~B()
	{
		cout << "~B" << endl;
	}
};

//运行结果是:~A ~B ~A
//在delete pa的时候，调用基类的析构函数，
//在delete pb的时候，调用子类的析构函数
//这样做是为了保证pa，pb指向的对象能够正确调用析构函数
int main()
{
	A* pa = new A;
	B* pb = new B;

	delete pa;
	delete pb;

	return 0;
}

重载、覆盖（重写）、隐藏（重定义）的对比

在这里插入图片描述

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

以下程序的运行结果是多少？

class A
{
public:
	virtual void func(int val = 1)
	{
		cout << "A->" << val << endl;
	}
	virtual void test()
	{
		func();
	}
};

class B : public A
{
public:
	virtual void func(int val = 0)
	{
		cout << "B->" << val << endl;
	}
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();

	return 0;
}

//A.  A->0 
//B.  B->1
//C.  A->1
//D.  B->0
//E.  编译报错
//F.  以上都不正确

答案是B
分析以下原因：
在这里插入图片描述

多态的原理

虚函数表

在讲虚函数表之前，先算一下下面这个Base类有多大？

cclass Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

int main()
{
	Base b;
	cout << sizeof(b) << endl;

	return 0;
}

在x86平台下，答案是8
这是为什么？明明只有一个int 类型，答案应该是4才对，为什么是8呢？这是因为Base类中还多了一个指针，_vfptr,对象中的这个指针我们叫作虚函数表指针。

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。（注意这里和继承中的虚基表没有一点关系，他们只是共用了同一个关键字virtual而已）

我们先思考两个问题：
1. 为什么构成多态的条件是父类的指针或者引用？子类的指针或者引用可以吗？
2. 为什么构成多态的条件是父类的指针或者引用？父类的对象可以吗？
在这里插入图片描述
为了分析方便，这里需要更改一下代码，将代码改为以下的样子：

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人 -- 全价" << endl;
	}

	virtual void Func1()
	{
		cout << "Person::Func1()" << endl;
	}

	virtual void Fun2()
	{
		cout << "Person::Func2()" << endl;
	}
};

class Student : public Person
{
public: 
	virtual void BuyTicket()
	{
		cout << "学生 -- 半价" << endl;
	}

	virtual void Fun3()
	{
		cout << "Student::Func3()" << endl;
	}
};

在这里插入图片描述
虚函数表本质是一个存虚函数指针的指针数组，也就是：函数指针数组一般情况下，数组的最后面放了nullptr。
也许有时候你会发现没有00 00 00 00,那是因为没有重新编译：如果你的代码修改了，那编译器不会再重新编译一次你的代码，而是在你原来的代码的基础上进行增加，所以你看不到00 00 00 00。

重新生成解决方案之后，你就可以看到了。

讲了这么多，就是为了验证之前的说法，到底那个地址是不是Func3()呢？


//这是函数指针的typedef 的方式
//(*FUN_PTR)()表示一个函数指针，它可以指向一个不返回值并且不带任何参数的函数
typedef void (*FUN_PTR)();

//虚函数表的本质是一个函数指针数组


//打印函数指针数组
//table就是虚表
//这里其实可以这样写：void PrintVFT(FUN_PTR table[])但是由于c中没有数组，都是指针，所以也就是下面这种写法
void PrintVFT(FUN_PTR* table)
{
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, table[i]);
		FUN_PTR f = table[i];
		f();
	}

	printf("\n");
}

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人 -- 全价" << endl;
	}

	virtual void Func1()
	{
		cout << "Person::Func1()" << endl;
	}

	virtual void Fun2()
	{
		cout << "Person::Func2()" << endl;
	}
};

class Student : public Person
{
public: 
	virtual void BuyTicket()
	{
		cout << "学生 -- 半价" << endl;
	}

	virtual void Fun3()
	{
		cout << "Student::Func3()" << endl;
	}
};

int main()
{
	Person ps;
	Student st;

	//这里&ps表示取出Person的指针，
	//(int*)&ps表示把Person类型的指针强制类型转换为int*型
	//*((int*)&ps)表示对int*型的指针解引用
	int vft1 = *((int*)&ps);

	//这里再把int类型的vft1强制类型转换为FUN_PTR*类型，
	//因为PrintVFT的参数列表就是FUN_PTR*类型
	PrintVFT((FUN_PTR*)vft1);


	int vft2 = *((int*)&st);
	PrintVFT((FUN_PTR*)vft2);
	return 0;
}

打印结果：
在这里插入图片描述
和上面我们的猜想一致！

其实这里这样做有几个比较巧妙的地方：

我们利用了虚表数组最后的值是00 00 00 00 来制造结束条件，也就是

for (size_t i = 0; table[i] != nullptr; i++)

这句代码
但是正如上面所说，如果你在此基础之上改动了代码，那么数组的最后就不一定是 00 00 00 00 了，此时程序会崩溃，因为结束条件不成立了！
所以我们都要重新编译一下！

为了验证我们的猜想，我们故意在Func1、Func2、Func3的函数体内打印了彼此的身份信息，若不打印，则只有地址出现，根本不知道哪个地址对应哪个函数。

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/cf7af86ef32241c0ae6f56c856588607.png)

};

int main()
{
	Derive d;
	cout << sizeof(d) << endl;

	int vft1 = *((int*)&d);
	//int vft2 = *((int*)((char*)&d+sizeof(Base1)));
	Base2* ptr = &d;
	int vft2 = *((int*)ptr);

	PrintVFT((FUN_PTR*)vft1);
	PrintVFT((FUN_PTR*)vft2);

	return 0;
}

在这里插入图片描述
为什么明明调用的都是func1()，但是地址却不相同？
第一个中的func1()的地址和第二个中func1的地址不一样？

那么，为什么调用Base1的指针的时候就是直接用this指针，但是到Base2时却要先跳到Base2的位置再跳回来修正this指针的位置？
在这里插入图片描述