编程语言
465
一、虚函数
1.重载,重写(覆盖),重定义(隐藏)的对比
重载: 两个函数在一个作用域,函数名相同,参数不同 . 重写(覆盖): 两个函数分别在基类和派生类的作用域 函数名,返回类型,参数都必须相同(协变例外),两个函数必须是虚函数 . 重定义(隐藏): 两个函数分别在基类和派生类的作用域 函数名相同,两个基类和派生类的同名函数不构成重写(覆盖)就是重定义
2.虚函数的重写
class person { public: void BuyTicket() //输出全为all //virtual void BuyTicket() //正确的输出 { cout << "all" << endl; } }; class student : public person { public: void BuyTicket() //virtual void BuyTicket() { cout << "half" << endl; } }; void Fun1(person& p) //注意引用 有子类赋值给父类(切割,切片) { p.BuyTicket(); } void Fun2(person* p) //指针也可以 { p->BuyTicket(); } int main() { student s; person p; Fun1(s); Fun1(p); Fun2(&s); Fun2(&p); return 0; } //virtual 关键字: 可以修饰成员函数,为了完成虚函数的重写,满足多态的条件之一 // : 可以在零菱形继承中,去完成虚继承,解决数据冗余和二义性 //虽然关键字一样,但他们之间没有一点关联 //多态的两个条件: //1.虚函数的重写 //2.父类对象的指针或引用去调用虚函数 //满足多态:跟指向对象有关,指向哪个对象调用的就是他的虚函数 //不满足多态:跟对象调用的类型有关,类型是什么调用的就是谁
①协变
基类与派生类虚函数的返回值类型不同 却仍然可以构成重写
//基类虚函数返回类型为基类对象的指针或引用,派生类虚拟函数返回类型为派生类对象的指针或引用,称为协变 class A{}; class B : public A{}; class person { public: virtual person* BuyTicket() //virtual A* BuyTicket() //而且不限于本父子类 //virtual B* BuyTicket() //但必须对应父子类,否则会出错 { cout << "all" << endl; return nullptr; } }; class student : public person { public: virtual student* BuyTicket() //如果虚函数返回类型是基类和派生类的指针或引用时,就会构成协变,此时无错误 //virtual B* BuyTicket() //virtual A* BuyTicket() { cout << "half" << endl; return nullptr; } }; void Fun1(person& p) { p.BuyTicket(); } int main() { student s; person p; Fun1(s); Fun1(p); return 0; }
②析构函数的重写
基类与派生类的函数名不同 但仍然可以构成重写
class person { public: //virtual ~person() ~person() //析构函数名被编译器处理为同一名称destruct { cout << "~person" << endl; } }; class student : public person { public: //virtual ~student() ~student() { cout << "~student" << endl; } }; int main() { person* p1 = new person; person* p2 = new student; //不加virtual会使得只调用person的析构 //调用不了student的析构函数,会内存泄漏 //virtual: `person `student `person , 感觉到了继承,根据情况调用不同的"同名"函数 //加上virtual,构成多态,调用的指针指向谁就调用谁的析构函数 //没有virtual: `person `person , 函数只调一个,知道有继承,但就是只能调一个 //不加上virtual,不构成多态,调用的指针类型是谁,调用的就是谁的析构函数 delete p1; delete p2; return 0; }
③虚函数的一些点
虚函数有一个指针的大小 虚函数重写生效的只是内容,而不是参数
class A { public: virtual void func(int val = 1) { cout << "A->" << val << endl; } virtual void test() //传入的是对象B指针,所以调用B中的func { func(); } }; class B : public A { public: void func(int val = 0) //重写生效的只是内容,而不是参数,所以缺省参数中 int val = 0 无效,所以 val == 1 { cout << "B->" << val << endl; } }; int main() { A* p = new B; p->test(); return 0; }
④抽象类(纯虚函数)
//在虚函数后面加上 =0 ,则这个函数就是纯虚函数 class car //有了纯虚函数,这个类就被成为抽象类 { public: virtual void drive() = 0;//纯虚函数,不需要实现,实现了不报错,但也没用 //virtual void drive() = 0 //{ // cout << "aa" << endl; //} }; class benz : public car { public: virtual void drive() { cout << "benz" << endl; } }; int main() { //car autocar; //抽象类实例化不出对象 benz autoccar; //抽象类的子类,也实例化不出对象,继承了纯虚函数(没有重写) //重写后即可以实例化出对象 return 0; }
纯虚函数的作用是
强迫重写 表示抽象的类型(现实中没有对应实体的)
二、两个关键字
1.final
修饰虚函数:可以阻止函数被重写,final无法对类中非虚函数进行修饰 修饰类: 可以阻止类被继承
class person { public: virtual void BuyTicket() final //此后,该函数不能再被重写 { cout << "all" << endl; } }; class student : public person { public: virtual void BuyTicket() //此时会报错,无法继承 { cout << "half" << endl; } }; class A final{}; //final后A不能被继承 class B : public A{};
2.override
可以检查出虚函数是否被成功重写
class A { public: void out() //virtual void out() { cout << "111" << endl; } }; class B : public A { public: virtual void out() override //如果检查出错则无法编译通过 { cout << "222" << endl; } };
三、多态的原理
1.原理
class base { public: virtual void fun1() { cout << "base:fun1()" << endl; } virtual void fun2() { cout << "base:fun2()" << endl; } private: int _b = 1; }; class derive : public base { public: virtual void fun1() { cout << "derive:fun1()" << endl; } private: int _d = 1; }; void function1(base& b) //运行时,到指向对象的虚表中,查找对应的虚函数的地址 { b.fun1(); } //多态如何实现的指向谁就调用谁的虚函数? //多态是在 运行时 到指向对象的虚表中,查找要调用虚函数的地址来调用 void function2(base b) //编译时,直接确定通过p的类型确定要调用函数的地址 { b.fun1(); } int main() { base b1; cout << sizeof(base) << endl; //16 8+4+对齐 == 16 //监视窗口中的_vfptr就是 虚函数表指针:简称虚表指针 //其本质是 指针数组(虚函数指针) derive d1; function1(b1); function1(d1); return 0; }
类里面有一个虚表,虚表里面存的指针指向虚函数 重写了,子指针改变指向 没重写,父指哪,子指哪
监视窗口中的_vfptr就是 虚函数表指针:简称虚表指针 其本质是 指针数组(虚函数指针) 一般来说对象前八个字节存的虚表指针 虚表指针数组最后一个指针为0x0000000000000000 表示这个虚函数数组结束了
2.验证虚函数和虚表的位置都是在代码段
class base { public: virtual void fun1() { cout << "base::fun1()" << endl; } virtual void fun2() { cout << "base::fun2()" << endl; } virtual void fun3() { cout << "base::fun3()" << endl; } private: int _b = 1; }; class derive : public base { public: virtual void fun1() { cout << "derive::fun1()" << endl; } private: int _d = 2; }; void test() { base b1; printf("_vftptr:%p\n", *(double*)&b1); printf("_vftptr:%p\n", *(long long*)&b1); //printf("_vftptr:%p\n", (long long)b1); 直接强制转换语法不接受 取对象前八个字节 int i = 0; int* p1 = &i; int* p2 = new int; const char* p3 = "hello"; printf("栈变量:%p\n", p1); printf("堆变量:%p\n", p2); printf("代码段常量:%p\n", p3); printf("代码段函数地址:%p\n", &base::fun3); printf("代码段函数地址:%p\n", test); } int main() { base b1; derive d1; test(); return 0; } //vs2022没有显示不出fun3()的情况 //有虚函数的对象,前八个字节是虚表指针的地址
四、动静态绑定
静态的绑定:编译时确定函数地址 动态的绑定:运行时到虚表中找虚函数的地址
编译时 是指: 高级语言转换为汇编语言时(初次检查错误) 运行时 是指: 程序开始运行,开始占用cpu和内存
class base { public: virtual void fun1() { cout << "base::fun1()" << endl; } private: int _b = 1; }; class derive : public base { public: virtual void fun1() { cout << "derive::fun1()" << endl; } private: int _d = 2; }; void f1(int i) {} void f2(double d) {} int main() { //静态的绑定 静态的多态 (静态:编译时确定函数地址) int i = 0; double d = 1.1; f1(i); f2(d); //动态绑定 动态的多态 (动态:运行时到虚表中找虚函数的地址) base* p = new base; p->fun1(); p = new derive; p->fun1(); return 0; }
五、设计函数展现_vftptr所有函数
1. 单继承展现虚表
class base { public: virtual void fun1() { cout << "base::fun1()" << endl; } virtual void fun2() { cout << "base::fun2()" << endl; } private: int b; }; class derive : public base { public: virtual void fun1() { cout << "derive::fun1()" << endl; } virtual void fun3() { cout << "derive::fun3()" << endl; } virtual void fun4() { cout << "derive::fun4()" << endl; } private: int d; }; //void(*p)() 定义一个函数指针变量 typedef void(*VF_PTR)(); //函数指针类型 //打印虚表 //void PrintVFTable(VF_PTR* pTable) void PrintVFTable(VF_PTR pTable[]) { for (size_t i = 0; pTable[i] != 0; ++i) //!=nullptr也可以 { printf("vftabel[%d]:%p->", i, pTable[i]); VF_PTR f = pTable[i]; f(); } cout << endl; } int main() { base b; derive d; //base的虚表 PrintVFTable((VF_PTR*)(*(long long*)&b)); PrintVFTable((VF_PTR*)(*(void**)&b)); //derive的虚表 //而监视窗口只有继承下来的fun1和fun2 PrintVFTable((VF_PTR*)(*(long long*)&d)); PrintVFTable((VF_PTR*)(*(void**)&d)); return 0; }
2.多继承展现虚表
//多继承 class base1 { public: virtual void fun1() { cout << "base::fun1()" << endl; } virtual void fun2() { cout << "base::fun2()" << endl; } private: int b1; }; class base2 { public: virtual void fun1() { cout << "base::fun1()" << endl; } virtual void fun2() { cout << "base::fun2()" << endl; } private: int b2; }; class derive : public base1,public base2 { public: virtual void fun1() { cout << "derive::fun1()" << endl; } virtual void fun3() { cout << "derive::fun3()" << endl; } private: int d; }; //typedef void (*VF_PTR)(); using VF_PTR = void(*)(); void PrintVFTable(VF_PTR pTable[]) { for (size_t i = 0; pTable[i] != nullptr; ++i) { printf("vftabel[%d]:%p->", i, pTable[i]); VF_PTR f = pTable[i]; f(); } cout << endl; } int main() { derive d; //base1 //监视窗口中只有fun1和fun2 PrintVFTable(( VF_PTR*)(*(void**)&d)); //我们发现derive的fun3存在于base1的虚表中 //base2 //监视窗口也有fun1和fun2 PrintVFTable((VF_PTR*)(*(void**)((char*)&d + sizeof(base1)))); return 0; }
子类独有的函数，存在第一个虚表中
关于函数指针数组指针的用法
第一种 typedef void(PFUNC)(); 第二种 using VF_PTR = void()();
留下了一个问题
在64位平台下base1 和 base2的函数内部只要操作不同,就会导致 base2无法依次访问时遇见nullptr停止,但是从虚表开头开始遍历却没有问题 32位平台下并没有这种问题
六、继承和多态
1.几个关于继承和多态的点
1.inline函数不可以是虚函数,inline函数没有地址,无法把地址放到虚函数表中 2.静态成员不可以是虚函数,静态成员函数没有this指针,使用 类型::成员函数 的调用方式无法访问虚表,所以静态成员函数无法放进虚函数表 3.构造函数不可以是虚函数,对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的 4.对象访问普通函数快还是虚函数快? 如果是普通对象一样快; 如果是指针对象或者是引用对象,普通函数快,构成多态,运行时调用虚函数需要需要到虚表中去查找;
2.继承多态的大小
class A { public: A(int x = 1) { cout << "aa" << endl; } virtual void Aa(){} }; class B :virtual public A { public: B(int x = 0) { cout << "bb" << endl; } virtual void Aa(){} }; int main() { B b; A a; cout << sizeof(B) << endl; printf("%p\n", &A::Aa); printf("%p\n", &B::Aa); //两个地址不一样,触发了重写 return 0; } //虚继承算出来大小是24 : virtual两个指针 8+8, 虚表+8 = 24 //不用虚继承大小是 8 : virtual算指针8字节
3.一道题
计算输出结果
class A { public: A(const char* s) { cout << s << endl; } }; class B :virtual public A { public: B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; } }; class C :virtual public A { public: C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; } }; class D :public B, public C { public: D(const char* s1,const char* s2,const char* s3,const char* s4) :B(s1, s2), C(s1, s3), A(s1) { cout << s4 << endl; } }; int main() { D* p = new D("class A", "class B", "class C", "class D"); delete p; return 0; }
1.A只有一个，所以A只构造一次,优先A构造 2.初始化列表优先于函数体，D最后 3.构造按继承顺序，即使先C(s1，s3)，B(s1，s2) 也是B先输出，C再输出 所以结果为ABCD
