多态——细致讲解

🔶多态基础概念
 🔶概念
  🔱多态性
  🔱多态——重新(覆盖)
 🔶示例
  🔶基本使用方法
  🔶特例
   🔱协变
   🔱析构函数重写
 🔱多态原理
  🔱1. 虚函数形成虚表
  🔱2. 虚函数存储位置(覆盖)
  🔱3. 多态中重写的虚函数存储位置
   🔱1. 重写原理——虚表
   🔱2. 单继承中，子类新增虚函数会存到父类的虚表中——普通继承
   🔱3. 单继承中，子类新增虚函数会存到父类的虚表中——虚继承
   🔱4. 同类公用一个虚表；父类和子类不共用一张虚表
 🔱多态例题
🔱经典问题

多态基础概念

概念

多态性

 1. 静态多态：函数重载和运算符重载
 2. 动态多态：继承和虚函数

多态——重写(覆盖）

 1. 父类的指针/引用调用虚函数
 2. 调用的虚函数必须是子类重写的虚函数
这样就能在指针调用相应的对象函数的时候使用相应的成员函数，具体看示例
这里条件很严格
重写的函数要是一摸一样——返回值，函数名，参数个数，参数位置，参数类型都要完全一样，虚函数之后的const也要一样

示例

基本使用方法

1. 父类中需要使用virtual修饰函数，子类中virtual可以不写

class A
{
public:
	virtual void func()
	{
		puts("A-->func");
	}
};
class B:public A
{
public:
	virtual void func()
	{
		puts("B-->func");
	}
};
int main()
{
	// 父类指向子类
	A* a1 = new B;
	a1->func();

	// 父类指向父类
	a1 = new A;
	a1->func();

	// 父类引用子类
	B tb;
	A& a2 = tb;
	a2.func();

	// 父类引用父类
	A ta;
	A& a3 = ta; // 不能直接使用a2=ta，引用不能重新赋值，虽然他不会报错，但是他的结果是错的
	a3.func();

	return 0;
}

---

2. final 修饰类——不能继承

修饰虚函数——不能背重写

3. override ——这个函数一定要重新父类的某一个虚函数

一定要注意这两个关键字加载虚函数结尾

特例

协变

虚函数的返回值可以不一样，只能出现父类返回父类的指针/引用，子类返回子类的指针/引用

不可以一个返回指针，一个返回引用
只能同时返回指针/同时返回引用

析构函数重写

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}
	~A()
	{
		cout << "delete A" << endl;
	}
	int _a = 1;

};
class B :public A
{
public:
	virtual void fun1()
	{
		cout << "B::fun1" << endl;
	}
	virtual void fun3()
	{
		cout << "B::fun3" << endl;
	}
	~B()
	{
		cout << "delete B" << endl;
	}
	int _b = 2;
};
int main()
{
	A* a = new B;
	delete a;

	return 0;
}

delete释放看的是类型，也就是说这里delete调用的是A的析构函数
根本上说，delete会被处理成—> destructor() + operator delete,所以他们能构成重写，在具体实现的时候需要写成virtual

	virtual ~A()
	{
		cout << "delete A" << endl;
	}

---

✨多态原理

✨1. 虚函数形成虚表

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}

};
int main()
{
	A a;
	return 0;
}

✨2. 虚函数存储位置

虚函数和普通函数放在一起，虚表存储在代码段

✨3. 多态中重写的虚函数存储位置

🎭1. 重写原理——虚表

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}

};
class B :public A
{
public:
	virtual void fun1()
	{
		cout << "B::fun1" << endl;
	}
};
int main()
{
	B b;
	return 0;
}

🎭2. 单继承中，子类新增虚函数会存到父类的虚表中——普通继承

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}

};
class B :public A
{
public:
	virtual void fun1()
	{
		cout << "B::fun1" << endl;
	}
	virtual void fun3()
	{
		cout << "B::fun3" << endl;
	}
};
int main()
{
	B b;
	print((T*)(*(int*)(&b)));

	return 0;
}

vs中虚表通常在最后一个都是0，Linux不是

🎭3. 单继承中，子类新增虚函数会存到父类的虚表中——虚继承

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}
	int _a = 1;

};
class B :virtual public A
{
public:
	virtual void fun1()
	{
		cout << "B::fun1" << endl;
	}
	virtual void fun3()
	{
		cout << "B::fun3" << endl;
	}
	int _b = 2;
};
int main()
{
	B b;
	A* a = &b; // 要注意这种写法，确保他能准确跳到下一个虚表处
	print((T*)(*(int*)(a)));

	print((T*)(*(int*)(&b)));

	return 0;
}

🎭4. 同类公用一个虚表；父类和子类不共用一张虚表

#include<iostream>
using namespace std;
typedef void (*T)();
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1" << endl;
	}
	virtual void fun2()
	{
		cout << "A::fun2" << endl;
	}
	int _a = 1;

};
class B :virtual public A
{
public:
	virtual void fun1()
	{
		cout << "B::fun1" << endl;
	}
	int _b = 2;
};
int main()
{
	A a;

	B b1;
	B b2;
	return 0;
}

---

🖼多态例题

class A
{
public:
	virtual void fun(int val = 1)
	{
		cout << "val = " << val << endl;
	}
	virtual void test()
	{
		fun();
	}
};
class B :public A
{
public:
	virtual void fun(int val = 0)
	{
		cout << "val = " << val << endl;
	}
};
int main()
{
	A* a = new B;
	a->test();

	return 0;
}
void print(T a[])
{
	for (int i = 0; a[i] != 0; i++)
	{
		printf("[%d]--->%p\n", i, a[i]);
	}
	puts("");
}
int main()
{
	B b;
	print((T*)(*(int*)(&b)));

	return 0;
}

1. 父类指向子类，调用的test函数，test函数是父类的虚函数，类内的函数有一个默认的this指针，test内部调用的fun函数实际上是this->fun(this类型是A*——父类的指针指向虚函数)，fun是子类重写的虚函数(函数是子类重写的虚函数)——满足多态条件
2. 虚函数中的this是根据是否重写确定的，这里的test没有被重写，是A*this指针，然后调用fun，fun是经过重写的函数，所以调用的是重写的函数
3. 虚函数继承的是函数的接口，重写的是函数的实现

所以缺省值才是1

---

#include<iostream>
using namespace std;

class A
{
public:
	virtual void fun(int val = 0)
	{
		printf("A::fun()--> %d", val);

	}
	virtual void test()
	{
		fun();
	}
};
class B:public A
{
public:
	void fun(int val = 1)
	{
		printf("B::fun()--> %d", val);
	}
};
int main()
{
	B b;
	b.test();

	return 0;
}

---

🔒经典问题

1. 什么是多态？
2. 什么是重载、重写(覆盖)、重定义(隐藏)？
3. 多态的实现原理？
4. inline函数可以是虚函数吗？

不可以；inline是在编译器将函数类容替换到函数调用处，是静态编译的。而虚函数是动态调用的，在编译器并不知道需要调用的是父 类还是子类的虚函数，所以不能够inline声明展开，所以编译器会忽略

5. 静态成员可以是虚函数吗？

不能，因为静态成员函数没有this指针，使用类型::成员函数
的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

6. 构造函数可以是虚函数吗？

不能，虚表在编译时生成
在调用构造函数之后，但是虚表指针在成员初始化之前

7. 析构函数可以是虚函数吗？

本就应该是，在A* a = new B;这种场景下，在释放子类对象时，需要将析构函数变成虚函数

8. 对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。如果构成多态，就是普通函数快，因为运行时调用虚函数需要到虚函数表中去查找。

9. 虚函数表是在什么阶段生成的，存在哪的？

虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？

菱形继承会造成祖宗类数据冗余的问题
在每一个继承自祖宗类的派生类中，使用一个指针，指向一个偏移量，根据偏移量找到的地址就是祖宗类的数据，并且这个数据只有一份

11. 什么是抽象类？抽象类的作用？

抽象类含有形如 virtual void fun() =0; 的基类/派生类
强制派生类重写父类的实现

---

从原理的角度理解，重写之后将fun虚函数进行覆盖，test是A*this调用经过重写的虚函数fun，符合多态的条件，并且继承的是接口不是实现，fun虚函数继承父类函数接口，并使用重写的虚函数实现，最终形成了这个样子

---

优秀多态文章
优秀多态文章
为什么要使用父类指针和引用实现多态，而不能使用对象？
虚析构函数
虚表位置
虚表位置
虚函数可以是inline吗？