🔶多态基础概念
🔶概念
🔱多态性
🔱多态——重新(覆盖)
🔶示例
🔶基本使用方法
🔶特例
🔱协变
🔱析构函数重写
🔱多态原理
🔱1. 虚函数形成虚表
🔱2. 虚函数存储位置(覆盖)
🔱3. 多态中重写的虚函数存储位置
🔱1. 重写原理——虚表
🔱2. 单继承中，子类新增虚函数会存到父类的虚表中——普通继承
🔱3. 单继承中，子类新增虚函数会存到父类的虚表中——虚继承
🔱4. 同类公用一个虚表；父类和子类不共用一张虚表
🔱多态例题
🔱经典问题
多态基础概念
概念
多态性
1. 静态多态：函数重载和运算符重载
2. 动态多态：继承和虚函数
多态——重写(覆盖）
1. 父类的指针/引用调用虚函数
2. 调用的虚函数必须是子类重写的虚函数
这样就能在指针调用相应的对象函数的时候使用相应的成员函数，具体看示例
这里条件很严格
重写的函数要是一摸一样——返回值，函数名，参数个数，参数位置，参数类型都要完全一样，虚函数之后的const也要一样
示例
基本使用方法
- 父类中需要使用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;
}
final修饰类——不能继承
修饰虚函数——不能背重写
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;
}
- 父类指向子类，调用的test函数，test函数是父类的虚函数，类内的函数有一个默认的this指针，test内部调用的fun函数实际上是this->fun
(this类型是A*——父类的指针指向虚函数)，fun是子类重写的虚函数(函数是子类重写的虚函数)——满足多态条件- 虚函数中的
this是根据是否重写确定的，这里的test没有被重写，是A*this指针，然后调用fun，fun是经过重写的函数，所以调用的是重写的函数- 虚函数继承的是函数的接口，重写的是函数的实现
所以缺省值才是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;
}
🔒经典问题
- 什么是多态？
- 什么是重载、重写(覆盖)、重定义(隐藏)？
- 多态的实现原理？
- inline函数可以是虚函数吗？
可以，不构成多态就是inline，构成多态就不是inline
- 静态成员可以是虚函数吗？
不能，因为静态成员函数没有this指针，使用类型::成员函数
的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
- 构造函数可以是虚函数吗？
不能，虚表在编译时生成
在调用构造函数之后，但是虚表指针在成员初始化之前
- 析构函数可以是虚函数吗？
本就应该是，在
A* a = new B;这种场景下，在释放子类对象时，需要将析构函数变成虚函数
- 对象访问普通函数快还是虚函数更快？
首先如果是普通对象，是一样快的。如果构成多态，就是普通函数快，因为运行时调用虚函数需要到虚函数表中去查找。
- 虚函数表是在什么阶段生成的，存在哪的？
虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
- C++菱形继承的问题？虚继承的原理？
菱形继承会造成
祖宗类数据冗余的问题
在每一个继承自祖宗类的派生类中，使用一个指针，指向一个偏移量，根据偏移量找到的地址就是祖宗类的数据，并且这个数据只有一份
- 什么是抽象类？抽象类的作用？
抽象类含有形如
virtual void fun() =0;的基类/派生类
强制派生类重写父类的实现
从
原理的角度理解，重写之后将fun虚函数进行覆盖，test是A*this调用经过重写的虚函数fun，符合多态的条件，并且继承的是接口不是实现，fun虚函数继承父类函数接口，并使用重写的虚函数实现，最终形成了这个样子
优秀多态文章
优秀多态文章
为什么要使用父类指针和引用实现多态，而不能使用对象？
虚析构函数
虚表位置
虚表位置
