C++学习记录——십팔 多态
文章目录
- 1、了解
- 2、多态的条件
-
- 1、析构函数重写
- 2、协变
- 3、关键字final和override
- 4、重写（覆盖）、重载、隐藏（重定义）对比
- 3、抽象类
- 4、多态的原理
-
- 1、虚函数表
- 2、原理
- 为什么父类指针或者引用可以，但实例化出的对象不可以形成多态？
- 3、打印虚表
- 4、多继承
- 5、动静态绑定
- 6、其它
1、了解
多态，就是多种形态，不同的对象去完成某个行为时会有不同的状态/结果。
在函数类型前加上virtual就表示这是虚函数
class Person
{
public:
virtual void Buy() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
//发生了重写/覆盖
virtual void Buy() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
p.Buy();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
结果就是一个全价一个半价，虽然发生了覆盖，但是不影响最终的结果，传哪个类的对象就打印什么。
多态的条件就是虚函数的重写和父类的指针或者引用去调用
刚才的代码，如果去掉引用或者重写或者两个都去掉，那就2个全价
这样的场景
class Person {
public:
~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
~Student() { cout << "~Student()" << endl; }
};
int main()
{
Person* ptr1 = new Person;
Person* ptr2 = new Student;
delete ptr1;
delete ptr2;
return 0;
}
ptr1释放时调用父类析构，但是ptr2也调用了父类析构，这是因为出现了隐藏关系，这时候多态就能派上用场了。
2、多态的条件
虚函数的重写——函数名、参数、返回值都相同
父类指针或者引用去调用
如果不满足多态，就看调用者的类型，调用这个类型的成员函数
满足多态，就看指向的对象的类型，调用这个类型的成员函数
class Person
{
public:
void Buy() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
virtual void Buy() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
p.Buy();
}
像这样父类没有virtal，不是多态，是隐藏，只不过子类对象去调用才能体现出隐藏。
Student st;
st.Buy();
如果父类函数有virtual，但是子类没有，那就输出一个全价和一个半价，但是这里仍然是多态。
子类可以不写，父类写了，编译器会认为子类重写了这个虚函数，这叫接口继承，子类会继承父类的函数，但是里面的实现会重写成子类的。
1、析构函数重写
func里面有父类指针指向了一个子类对象，这个条件满足，所以要加上另一个条件，把父类析构也写上virtual就可以形成多态了。
这里还可以这样理解，析构函数名字虽然不同，但编译器把它们统一变成了destructor
2、协变
虚函数的重写有三个不同，有一个例外就是返回值不同。但不能无脑不同，它要求必须是父子关系的指针或者引用。
class Person
{
public:
virtual Person* Buy()
{
cout << "买票-全价" << endl;
return this;
}
};
class Student : public Person
{
public:
virtual Student* Buy()
{
cout << "买票-半价" << endl;
return this;
}
};
它可以不只是现有类的指针，比如说在这之前定义A父类和B子类，就可以用A和B的指针。返回值类型也得对应，返回类对象就不行。
虚函数重写的例外有两个，一个是接口继承，一个是协变。
3、关键字final和override
final
修饰虚函数后这个虚函数不能被重写
class Car
{
public:
virtual void Drive() final {}
};
class Benz : public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}
override
检查是否完成重写，不是就报错
class Car
{
public:
virtual void Drive() {}
};
class Benz : public Car
{
public:
virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}
4、重写（覆盖）、重载、隐藏（重定义）对比
重载：两个函数在同一作用域；函数名相同，参数不同
重写：两个函数分别在基类和派生类的作用域；函数名/参数/返回值都必须相同（协变例外）；两个函数必须是虚函数
重定义：两个函数分别在基类和派生类的作用域；函数名相同；两个基类和派生类的同名函数不构成重写就是重定义
3、抽象类
在虚函数后写上=0，这个函数就是纯虚函数，包含纯虚函数的类是抽象类，这种类不能实例化出对象。
一个类继承抽象类后也是抽象类，因为包含纯虚函数。如果重写了纯虚函数，子类的那个函数就不是纯虚函数，这时候子类就可以实例化对象了。
4、多态的原理
1、虚函数表
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
char _ch;
};
int main()
{
cout << sizeof(Base) << endl;
Base bb;
return 0;
}
结果是12.两个变量占了8个字节，但是多出来的4是什么？
多出来的这个指针就是虚函数表指针。
2、原理
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person Mike;
Func(Mike);
Student Johnson;
Func(Johnson);
return 0;
}
func函数里，传父类对象，M就会有父类的虚函数，传子类对象，就会有子类的虚函数。父类虚表存父类虚函数，子类虚表存子类虚函数。如果不构成多态，那就什么类就用什么类的虚函数；如果是多态，就去指向的对象的虚表里去找。所以p这个指针看的只是虚表，它并不知道是哪个类对象。
为什么虚函数表不只放在类对象里，而是要找单独一个区域去放虚函数表？因为可能有多个虚函数。虚函数表本质是一个虚函数指针数组 ，如果有多个虚函数，就会有多个虚函数表。发生了重写，虚函数表就会被覆盖，没有就不会覆盖。虚函数表是在编译时就准备好的。虚函数表按声明顺序来确定数组下标的。
为什么父类指针或者引用可以，但实例化出的对象不可以形成多态？
父类指针或者引用可以指向虚函数表，子类会把父类的那部分切出来，让它指向对象，对应的还是子类的虚函数表。如果是对象，父类对象没问题，但如果是子类对象，那么会发生拷贝，把父类的内容拷贝到子类，那虚表会拷贝呢？不会，这个风险大，拷贝了可能很多映射关系就乱了。
---------------------------------------------------------------------------------------------------------------
虚函数和普通函数一样，存在代码段。
在main栈帧里，类实例化了对象，对象有一个指针，指向虚函数表，表里存的就是虚函数的地址。
3、打印虚表
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() { cout << "Base::func2" << endl; }
void func3() { cout << "Derive::func3" << endl; }
private:
int _b = 1;
};
class Derive :public Base {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func4() { cout << "Derive::func4" << endl; }
private:
int _d = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}
如果在子类中写一个父类没有的函数，前面加上virtual，这时候如果调用监视窗口会发现它不在虚表，但是真的不在吗？内存窗口也不一定能看得出来，这样的话就得打印虚表来看了。
typedef void(*VF_PTR)();//函数指针的typedef需要把新定义的名字放在括号里，所以VF_PTR是void(*)()
void PrintVFTable(VF_PTR table[])
{
for (int i = 0; table[i] != nullptr; ++i)
{
printf("[%d]:%p\n", i, table[i]);
}
cout << endl;
}
int main()
{
Base b;
Derive d;
//要找到这个虚表,根据之前所写，虚表指针在这个对象的前4/8个字节
PrintVFTable((VF_PTR*)(*(int*)&b));
PrintVFTable((VF_PTR*)(*(int*)&d));
return 0;
}
我们可以把类对象的地址强制转为int*类型，再解引用就得到了地址的前4个字节，然后把这个结果再转成VF_PTR类型传过去就好了。
另外的写法就是二级指针
PrintVFTable((*(VF_PTR**)&b));
PrintVFTable((*(VF_PTR**)&d));
但是第一种只能在32位下走，第二种两个都行。第一种int改成longlong就可以适应64位。
补全打印虚表函数
void PrintVFTable(VF_PTR* table)
{
for (int i = 0; table[i] != nullptr; ++i)
{
printf("[%d]:%p->", i, table[i]);
VF_PTR f = table[i];
f();
}
cout << endl;
}
就可以打印出来两个对象的虚表。func4也在其中。
虚表是编译阶段生成的，对象中虚表指针是在构造函数的初始化列表初始化的，虚表存在哪里？
可以通过这个方法来看。
int x = 0;
static int y = 0;//静态区
int* z = new int;
const char* p = "asdasd asda";//常量区
printf("栈对象: %p\n", &x);
printf("堆对象: %p\n", z);
printf("静态区对象: %p\n", &y);
printf("常量区对象: %p\n", p);
printf("b对象虚表: %p\n", *((int*)&b));
printf("d对象虚表: %p\n", *((int*)&b));
离常量区近，应当是在常量区，不过也有编译器放在静态区。
4、多继承
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;
};
int main()
{
Derive d;
return 0;
}
d有两张虚表，base1和base2，func1发生了重写，两个虚表都有各自的func2，func3在哪里？我们可以打印虚表，但是有两个虚表，base1放在前头，所以按照之前的办法就只打印了base1,2没打印，可以用+sizeof(Base1)或者用偏移来打印base2.
//PrintVFTable((VF_PTR*)(*(int*)((char*)&d + sizeof(Base1))));
Base2* ptr2 = &d;
PrintVFTable((VF_PTR*)(*(int*)(ptr2)));
ptr2发生了指针的偏移，正好就指向了Base2的虚表。最后结果就是放在第一个虚表中。
上面的代码中，func1重写了，但是地址不一样，但它们确实重写了。
Base1* ptr1 = &d;
Base2* ptr2 = &d;
ptr1->func1();
ptr2->func1();
反汇编代码中，ptr1->func1()call到了Base1的虚表地址，call后是一个jmp指令，jmp后面括号里的就是函数真实的地址，然后开始建立栈帧等；ptr2->func1()call的地址就不一样，jmp后函数的地址也不一样，并且在这次jmp后接下来的反汇编出现了一句sub，一句jmp，然后再接一句jmp，才到真正执行的函数的地址。它之所以这样走，是因为里面有一个sub，那行代码后还有一个ecx，ecx就是this指针；ptr1调用的func是子类的函数，ptr1指向对象的开始，ecx就指向对象的开始，所以不需要另外的处理；但是ptr2并不是这样，此时this并没有指向对象的开始，所以多出来的步骤是为了修正this指针。
5、动静态绑定
- 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，
比如：函数重载，cin， cout- 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体
行为，调用具体的函数，也称为动态多态。- 本小节之前(5.2小节)买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑
定。
6、其它
class A
{
public:
virtual void func()
{
}
public:
int _a;
};
class B : virtual public A
{
public:
virtual void func()
{
}
public:
int _b;
};
class C : virtual public A
{
public:
virtual void func()
{
}
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
ABC都有函数，如果D不写，就会警告，说A的func函数重写不明确。A的虚表应当放B还是C重写的函数？无法确定，这时候就需要D去完成最终的重写。初始化也一样，D里面写了代码，BCA都对A初始化了，但是A用自己的初始化，如果没写A对自己的初始化，那就报错。
如果BC有新增的虚函数，不会放进A的虚表。不看A的话，D继承BC，D应当有两个虚表，那再加上A，就有了A的公共的虚表，所以D有三个虚表，一张A的虚表（指向虚函数表，里面存放函数指针），两张虚基表(指向存有偏移量的表)。
结束。