C++多态
文章目录
-
- 1.多态的概念
- 2.多态的定义及实现
-
- 2.1多态的构成条件
- 2.2 虚函数的重写
- 2.3虚函数重写的例外
- 2.4C++11中 override 和 final
- 2.6重载、覆盖(重写)、隐藏(重定义)的对比
- 3.抽象类
-
- 3.1接口函数和实现继承
- 4多态的原理
-
- 4.1虚函数表
- 4.2多态的原理
- 4.3动态绑定和静态绑定
- 5.单继承和多继承的虚函数表
-
- 5.1单继承中的虚表
- 5.2多继承中的虚表
1.多态的概念
多态的概念：如同字面意思一样就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
举个例子，视频平台中，你是会员和非会员就会有不用状态，会员看视频的广告就会相对较少，而非会员的广告就会相对较多，这就是多态
C++中有两种多态性，一种是静态的多态、一种是动态的多态；
静态的多态：函数重载,看起来调用同一个函数却有不同的行为，在编译时实现。
动态的多态：一个父类的引用或指针去调用同一个函数，传递不同的对象，会调用不同的函数。动态：原理是运行时实现。
2.多态的定义及实现
2.1多态的构成条件
继承中要构成多态还有两个条件：
- 必须通过基类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
虚函数
虚函数：被virtual修饰的类成员函数称为虚函数。
注意的是：
1.虚函数只能是类里的一个成员函数，不能是静态成员或普通函数
2.定义虚函数后包含该基类的派生类中的同名函数自动变为虚函数，也就是说派生类中那个同名函数可以不加virtual也是虚函数
3.这里的关键字virtual与继承中虚拟继承的virtual是没有关系的
2.2 虚函数的重写
虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
class Person
{
public:
//基类函数加上virtual符合条件的构成虚函数重写
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
class Soldier : public Person
{
public:
//建议加上virtual
void BuyTicket() { cout << "优先-买票-半价" << endl; }
};
注意的是：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用
有了虚函数重写就能实现多态，下面是相关演示
class Person
{
public:
//基类函数加上virtual符合条件的构成虚函数重写
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
class Soldier : public Person
{
public:
void BuyTicket() { cout << "优先-买票-半价" << endl; }
};
void buyone(Person& p)//这里为引用
{
p.BuyTicket();
}
int main()
{
Person s;
Student p;
Soldier d;
buyone(s);
buyone(p);
buyone(d);
return 0;
}
2.3虚函数重写的例外
虚函数重写有两个例外：
1.协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变
class Person
{
public:
virtual Person* BuyTicket()
{ cout << "买票-全价" << endl; return new Person; }
};
class Student : public Person
{
public:
virtual Student* BuyTicket()
{ cout << "买票-半价" << endl; return new Student; }
};
class Soldier : public Person
{
public:
virtual Soldier* BuyTicket()
{ cout << "优先-买票-半价" << endl; return new Soldier; }
};
void buyone(Person& p)//这里为引用
{
p.BuyTicket();
}
int main()
{
Person s;
Student p;
Soldier d;
buyone(s);
buyone(p);
buyone(d);
return 0;
}
2.析构函数的重写
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，看起来违背了重写的规则，其实不是，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor因此也是重写。
那么就有一个问题为啥这里要让析构函数构成重写，这里就有一个问题析构函数可以是虚函数吗，为什么。这是一些笔试和面试经常问到的地方，而下面这个场景就可以解答
class Person
{
public:
~Person()
{
cout << "~Person" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
cout << "~Student" <<endl;
}
};
int main()
{
Person* p = new Person;
delete p;
p = new Student;//这里我们期望是一个多态调用
delete p;
return 0;
}
但是从结果来看并不是多态调用
这是因为此时发生的是普通调用
class Person
{
public:
~Person()
{
cout << "~Person" << endl;
}
};
class Student : public Person
{
public:
~Student()
{
cout << "~Student" <<endl;
}
};
int main()
{
Person* p = new Person;
delete p;
//这里真正的调用是p->destructor() delete(p)
p = new Student;
//为了将这里调用多态，编译器才将析构处理成destructor()来满足多态调用的条件，但是满足多态调用的条件还有一个就是虚函数，因此给析构函数加上virtual才能在这里真正解决
delete p;
return 0;
}
这里总结：如果我们不加上virtual就不能形成多态，destructor()是由编译器完成的，不用我们实现。这里的场景不加virtual就会造成泄漏。因此我们再写代码时尽量在基类的析构函数加上virtual。
2.4C++11中 override 和 final
看到现在我们可以知道C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和fifinal两个关键字，可以帮助用户检测是否重写。
- final：修饰虚函数，表示该虚函数不能再被重写，和修饰类不能被继承
从图中报错就能看出不能被重写了。有了这个final后如果我们不想让一个类被继承也有方法了，在类后面加上final，为最终类，这样这个类就不会被继承了
- override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Person
{
public:
virtual Person* BuyTicket()
{
cout << "买票-全价" << endl;
return new Person;
}
~Person()
{
cout << "~Person" << endl;
}
};
class Student : public Person
{
public:
virtual Student* BuyTicket() override//检查是否完成重写
{
cout << "买票-半价" << endl;
return new Student;
}
~Student()
{
cout << "~Student" <<endl;
}
};
2.6重载、覆盖(重写)、隐藏(重定义)的对比
重载： 两个函数在同一个作用域
函数名/参数相同
重写(覆盖)： 两个函数分别在基类和派生类的作用域
函数名/参数/返回值都必须相同（协变例外）
两个函数必须是虚函数
重定义(隐藏)：两个函数分别在基类和派生类的作用域
函数名相同
两个基类和派生类的同名函数都不构成重写是重定义
在基类和子类中同名的函数不是重写就是重定义；
3.抽象类
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
class Car
{
public:
virtual void carplay() = 0;
};
class Benz :public Car
{
public:
virtual void carplay()
{
cout << "Benz- " << endl;
}
};
class BMW :public Car
{
public:
virtual void carplay()
{
cout << "BMW- " << endl;
}
};
void Test()
{
Car* pBenz = new Benz;
pBenz->carplay();
Car* pBMW = new BMW;
pBMW->carplay();
}
3.1接口函数和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数
4多态的原理
4.1虚函数表
// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
virtual void pmap()
{
cout << "pmap()" << endl;
}
private:
int _b = 1;
};
int main()
{
Base b;
return 0;
}
通过测试就会发现这里b对象是8bytes，我们观察发现除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表
// 针对上面的代码我们做出以下改造
// 1.增加一个派生类Derive去继承Base
// 2.Derive中重写pmap1
// 3.Base再增加一个虚函数pmap2和一个普通函数pmap3
class Base
{
public:
virtual void pmap1()
{
cout << "Base::pmap1()" << endl;
}
virtual void pmap2()
{
cout << "Base::pmap2()" << endl;
}
void pmap3()
{
cout << "Base::pmap3()" << endl;
}
private:
int _b = 1;
};
class Derive :public Base
{
public:
virtual void pmap1()
{
cout << "Derive::pmap1()" << endl;
}
private:
int _d = 2;
};
int main()
{
Base a;
Derive b;
return 0;
}
将这段代码运行，并打开监视窗口
通过观察可以发现
- 派生类对象b中也有一个虚表指针，b对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就存在部分,另一部分则是b自己的成员。
- 基类a对象和派生类b对象虚表是不一样的，这里我们发现pmap1完成了重写，所以b的虚表中存的是重写Derive::pmap1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
- 另外pmap2继承下来后是虚函数，所以放进了虚表，pmap3也继承下来了，但是不是虚函数，所以不会放进虚表。
- 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
- 派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。 - 这里有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？
答：虚函数存在虚表，虚表存在对象中。
注意上面的回答的错的。但是很多都是这样深以为然的。
注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。
那么虚表存在哪的呢？
实际我们去验证一下会发现vs下是存在代码段的
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 a;
Student b;
Func(a);
Func(b);
return 0;
}
运行结果可以看到实现了不同对象实现不同效果。
我们通过汇编可以看出满足多态后函数调用不是在编译时确定而是在运行到对象的虚表中找的
不满足多态的话则是在编译阶段就确定好的
4.3动态绑定和静态绑定
- 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
- 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
- 多态，多数都是动态绑定
5.单继承和多继承的虚函数表
5.1单继承中的虚表
我们看下面这段代码：
class Person
{
public:
virtual void func1()
{
cout << "Person func1()" << endl;
}
virtual void func2()
{
cout << "Person func2()" << endl;
}
};
class Student :public Person
{
public:
virtual void func1()
{
cout << "Student func1()" << endl;
}
virtual void func3()
{
cout << "Student func3()" << endl;
}
};
int main()
{
Person p;
Student s;
return 0;
}
我们打开监视窗口后发现s对象里面只有一个_vfptr，指向一张虚表，而虚表里的时func1和func2虚函数的地址，但是派生类对象s 还有一个虚函数func3，却没有发现，因此我们就要用其他方法进行找出。
如果我们要得到虚表指针的内容，由于vs这个平台，虚表指针是保存在开始的，需要先得到对象地址，强转成int *得到前四个字节，就是虚表指针的地址，再解引用，得到虚表指针的内容再强转成函数二级指针
class Person
{
public:
virtual void func1()
{
cout << "Person func1()" << endl;
}
virtual void func2()
{
cout << "Person func2()" << endl;
}
};
class Student :public Person
{
public:
virtual void func1()
{
cout << "Student func1()" << endl;
}
virtual void func3()
{
cout << "Student func3()" << endl;
}
};
typedef void(*VFPTR)();//声明一个函数指针即 typedef void (*)() VFPTR;
void PrintVfTable(VFPTR* vftable)
{
for (int i = 0; vftable[i] != nullptr; i++)
{
printf("vftable[%d]:%p\n", i, vftable[i]);
VFPTR fun = vftable[i];
fun();
}
cout << endl;
}
int main()
{
Person p;
Student s;
PrintVfTable((VFPTR*)*(int*)&p);
PrintVfTable((VFPTR*)*(int*)&s);
return 0;
}
验证了我们的猜想。
5.2多继承中的虚表
class Base1
{
public:
virtual void func1()
{
cout << "Base1 : func1()" << endl;
}
virtual void func2()
{
cout << "Base1 : func2()" << endl;
}
protected:
int _a;
};
class Base2
{
public:
virtual void func1()
{
cout << "Base2 : func1()" << endl;
}
virtual void func2()
{
cout << "Base2 : func2()" << endl;
}
protected:
int _b;
};
//多继承
class Deirve :public Base1, public Base2
{
public:
virtual void func1()
{
cout << "Deirve : func1()" << endl;
}
virtual void func4()
{
cout << "Deirve : func4()" << endl;
}
protected:
int _c;
};
typedef void(*VFPTR)();
void PrintVfTable(VFPTR* vftable) {
printf("虚表地址：%p\n", vftable);
for (int i = 0; vftable[i] != nullptr; i++) {
//打印虚表内容
printf("vftable[%d]:%p\n", i, vftable[i]);
//调用这个函数
VFPTR fun = vftable[i];
fun();
}
cout << endl;
}
int main()
{
Deirve d;
//打印继承Base1的虚表
PrintVfTable((VFPTR*)*(int*)&d);
//打印继承Base2的虚表
//加Base1大小的字节数，到Base2的虚表指针。
//要加先强转成char *，步长为一个字节。不强转的话，步长为Deirve
PrintVfTable((VFPTR*)*(int*)((char*)&d + sizeof(Base1)));
return 0;
}
观察下图可以发现多继承派生类中未重写的虚函数放在第一个继承基类部分的虚函数表中
