文章目录
一.多态的概念
举个简单的例子:买火车票,学生,军人,儿童都是买票,但价格不一样。
同样干一件事情,不同类的对象,差别挺大的
代码:传的都是同一个函数,但效果不一样
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 ps;
Student st;
Func(ps);
Func(st);
return 0;
}
虚函数
虚函数:即被virtual修饰的类成员函数称为虚函数
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};
虚函数的重写
虚函数重写需要三同:函数名,参数,返回值
也称子类的虚函数重写了父类的虚函数
构成多态的两个条件
1.父子类完成虚函数的重写
2.父类的指针或者引用取调用虚函数
如果不是指针和引用,那就不是多态了:
但又有两个例外:
协变:
父类重写子类虚函数时,与子类虚函数返回值类型不同。即子类虚函数返回子类对象的指针或者引用,父类虚函数返回父类对象的指针或者引用时,称为协变。
class A {};
class B : public A {};
class Person {
public:
virtual A* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student : public Person {
public:
virtual B* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
这里调用自己的指针也行:
class Person {
public:
virtual Person* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student : public Person {
public:
virtual Student* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}
};
析构函数的重写
引例:
class Person
{
public:
Person()
{
cout << "Person()" << endl;
}
~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
Student()
{
cout << "Student()" << endl;
}
~Student()
{
cout << "~Student()" << endl;
}
};
int main()
{
Person* ps = new Person;
Person* st = new Student;
delete ps;
delete st;
return 0;
}
运行会发现,st调用的是Person的析构,并且Person的析构掉了两次,但构造函数调用了三次
看似没问题,如果st是这样的,那么调不到st的析构就会产生内存泄漏
class Student : public Person
{
public:
~Student()
{
delete[] _ptr;
cout << "~Student" << endl;
}
private:
int* _ptr = new int[10];
};
画个图:
我们所期望的是父类调用父类的析构函数,子类调用子类的析构函数,次数一样
编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor。所以构成重写,变成了:
ps->destructor + operator delete(ps);
st->destructor + operator delete(st);
class Person
{
public:
//destructor
virtual ~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person
{
public:
//destructor
virtual ~Student()
{
delete[] _ptr;
cout << "~Student" << endl;
}
private:
int* _ptr = new int[10];
};
所以在写继承函数的析构时,最好加上virtual
其实还有第三个例外,子类不写virtual也可以重写
class Person {
public:
virtual Person* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student : public Person {
public:
Student* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
一个题:
以下程序会输出什么:A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
#include <iostream>
using namespace std;
class A
{
public:
virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
virtual void test() { func(); }
};
class B : public A
{
public:
void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
B* p = new B;
p->test();
return 0;
}
这里选B
首先父类和子类的函数名,参数,返回值相同,所以构成虚函数重写,跟缺省参数无关
然后这里test的this指针是A的,继承只是一个说法,实践中不会把A(父类)的函数直接弄下来,先在B(子类)查找,后在A(父类)查找,这也是函数同名构成隐藏的原因,体会一下。
之后this->func()明显的构成多态,因为this是父类指针,同时func()构成重写,调用的B的func()
最后构成多态重写的实现,缺省值不动,函数的结构部分(函数名参数返回值等)用的是父类
不建议缺省值这么写,要么一样,要么不写
override 和 final
final
如果不想一个类被继承的话,加个final
上面这个final用法不常用
如何让一个类不能被继承
C++98的方法:父类的构造函数私有,子类的构造无法生成和实现,导致子类对象无法实例化
class Car
{
private:
Car()
{}
};
class Benz : public Car
{
public:
virtual void Dirve() { cout << "Benz" << endl; }
};
C++11的方法是用final修饰的类叫做最终类,不能被继承
class Car final
{
public:
Car()
{}
};
class Benz : public Car
{
public:
virtual void Dirve() { cout << "Benz" << endl; }
};
override
检查子类虚函数是否重写了父类某个虚函数,如果没有重写编译就报错
例子:
把父类的virtual也会报错
二.重载,覆写(重写),隐藏(重定义)的对比
三.底层
引例:下面代码会输出多少,在x86的环境下
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
char _ch = 'a';
};
int main()
{
cout << sizeof(Base) << endl;
return 0;
}
是12
实例化一个对象,通过调试看以下
有个指针,叫做虚函数表指针,简称虚表指针(只要有虚函数就有这个)
以下面这串代码为例
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
void Func3()
{
cout << "Base::Func3()" << endl;
}
private:
int _b = 1;
};
int main()
{
Base b;
return 0;
}
通过调试我们可以看出
这个东西是用来实现多态的
接下来以这串代码来讲解如何实现多态
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
int _i = 1;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
int _j = 2;
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person Mike;
Func(Mike);
Student Johnson;
Func(Johnson);
return 0;
}
画个图
同类型的对象虚表共用的是一个。
虚函数存在哪?
虚函数跟普通函数一样,都是存在代码段,不是存在虚表的
虚表中存的仅仅是虚函数地址
那虚表存在哪个区域的?(栈 、堆、常量区、静态区 )
首先进程运行中只关心指令
进程->指令
类->实例化对象->指令
函数->指令
肯定不是栈,栈用完就删
通过以下代码对比一下:
int main()
{
int i = 0;
static int j = 1;
int* p1 = new int;
const char* p2 = "xxxxxxxx";
printf("栈:%p\n", &i);
printf("静态区:%p\n", &j);
printf("堆:%p\n", p1);
printf("常量区:%p\n", p2);
Person p;
Student s;
Person* p3 = &p;
Student* p4 = &s;
printf("Person虚表地址:%p\n", *(int*)p3);
printf("Student虚表地址:%p\n", *(int*)p4);
return 0;
}
发现跟常量区的地址很相近
四.单继承和多继承关系的虚函数表
单继承中的虚函数表
例子:
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() { cout << "Base::func2" << endl; }
private:
int a;
};
class Derive :public Base {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
virtual void func4() { cout << "Derive::func4" << endl; }
private:
int b;
};
int main()
{
Base b;
Derive d;
return 0;
}
通过监视窗口就会发现b是正常的,d只有b继承过来的
这是VS的工程师故意的应该,看内存就能看见其余两个虚函数的地址
那么如何确定后面两个指针分别对应的是func3,func4
打印虚表的程序:
虚函数表本质是一个函数指针数组
//函数指针
void (*p)();
//函数指针数组
void (*p[10])();
太长了,typedef一下:
typedef void(*VFPTR)();
//函数指针
VFPTR p1;
//函数指针数组
VFPTR p2[10];
那么还有一个问题,如何拿到虚函数表第一个地址
强转:
Derive d;
VFPTR* prt = (VFPTR*)(*(int*)&d);
这就是成品:
void PrintVFT(VFPTR* ptr)
{
for (size_t i = 0;i<4;i++)
{
printf("%p\n",ptr[i]);
}
}
int main()
{
Base b;
Derive d;
VFPTR* ptr = (VFPTR*)(*(int*)&d);
PrintVFT(ptr);
return 0;
}
除了打印指针还能调用函数
再个a一个1,b一个2的值,就能清楚看出其的储存方式
多继承中的虚函数表
引例:以下代码会输出什么,sizeof(Derive)多大
class Base1 {
public:
virtual void func1() { cout << "Base1::func1" << endl; }
virtual void func2() { cout << "Base1::func2" << endl; }
private:
int b1 = 1;
};
class Base2 {
public:
virtual void func1() { cout << "Base2::func1" << endl; }
virtual void func2() { cout << "Base2::func2" << endl; }
private:
int b2 = 2;
};
class Derive :public Base1, public Base2 {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
private:
int d1 = 3;
};
int main()
{
cout << sizeof(Derive) << endl;
return 0;
}
答案是20
它是这样的
那么子类中的func1与func3存在哪里
用以下代码查看:
typedef void(*VFPTR)();
void PrintVTable(VFPTR vTable[])
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%p,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
//切片也可以搞出第二个虚函数表的地址
//VFPTR* vTableb2 = (VFPTR*)(*(int*)ptr);
PrintVTable(vTableb2);
return 0;
}
看出func3放进来第一个虚函数表中
五.抽象类
在虚函数的后面写上 =0 ,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。
继承了也实例化不出对象
有什么意义呢?
就是强制子类完成重写
class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
int main()
{
Benz b;
return 0;
}
抽象类与override的区别是
抽象类是强制子类重写虚函数
override已经重写,在语法上检查是否有错误
接口继承和实现继承
就做个了解:
普通函数的继承是一种实现继承,子类继承了父类函数,可以使用函数,继承的是函数的实现。
虚函数的继承是一种接口继承,子类继承的是父类虚函数的接口,目的是为了重写,达成多态,继承的是接口。
所以如果不实现多态,不要把函数定义成虚函数。
这里区分一下虚表和虚基表
虚表:虚函数表,存的虚函数,目标实现多态
虚基表:存的当前位置距离虚基类部分的偏移量,解决菱形继承数据冗余和二义性
六.菱形继承、菱形虚拟继承
引例:先以菱形继承为例,以下代码多少个字节
class A
{
public:
virtual void func1() { cout << "A::func1" << endl; }
int _a;
};
class B : public A
{
public:
virtual void func2() { cout << "B::func2" << endl; }
int _b;
};
class C : public A
{
public:
virtual void func3() { cout << "C::func3" << endl; }
int _c;
};
class D : public B, public C
{
public:
virtual void func4() { cout << "D::func4" << endl; }
int _d;
};
int main()
{
D d;
cout << sizeof(d) << endl;
return 0;
}
28个字节
画个图:
菱形虚拟继承:
以下代码输出的多少?
class A
{
public:
virtual void func1() { cout << "A::func1" << endl; }
int _a;
};
class B : virtual public A
{
public:
virtual void func2() { cout << "B::func2" << endl; }
int _b;
};
class C : virtual public A
{
public:
virtual void func3() { cout << "C::func3" << endl; }
int _c;
};
class D : public B, public C
{
public:
virtual void func4() { cout << "D::func4" << endl; }
int _d;
};
int main()
{
D d;
cout << sizeof(d) << endl;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
36个字节
虚基类A是共享的
以上了解以下即可