准备
博主:大大怪先森(记得关注哦!）
编程环境：vs2013
所示代码：码源
提示：写完文章后，目录可以自动生成
文章目录
前言
本文将讲解c++多态的相关知识！！！
提示：以下是本篇文章正文内容
一、多态的概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
打个比喻：
就好像是你和一个VIP成员取取银行取钱的时候，VIP用户可以去VIP通道取钱而你只能去普通通道取钱，看人办事！！！！
二、多态的定义和实现
2.1多态的构成条件
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为
那么在继承中要构成多态还有两个条件：
- 必须通过基类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2.2虚函数
虚函数：即被virtual修饰的类成员函数称为函数
class Person
{
public:
virtual void BuyTicket()//虚函数
{
cout << "票价 - 全价" << endl;
return;
}
};
2.3函数的重写
虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数
class Person
{
public:
virtual void BuyTicket()
{
cout << "票价 - 全价" << endl;
return;
}
};
class Student : public Person
{
public:
//子类中满足三同（函数名，参数，返回值）虚函数，叫做重写（覆盖）
//virtual void BuyTicket()
void BuyTicket()
{
cout << "票价 - 半价" << endl;
}
};
//构成多态，跟p的类型没有关系，传的那个类型对象，调用的就是这个类型的函数
//----和对象有关系
//不构成多态，调用的就是p类型的函数 --- 跟类型有关
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
//int i = 1;
//double d = 2.22;
//cout << i;//调用的是cout.operator<<(int)
//cout << d;
Person ps;
Student st;
//Func(ps);
//Func(st);
//st.BuyTicket();
st.Person::BuyTicket();
return 0;
}
2.3.1协变和析构（两个例外）
- 协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
class A{};
class B : public A{};
class Person
{
public:
/*virtual A* BuyTicket()
{
cout << "买票 -- 半价" << endl;
return nullptr;
}*/
virtual Person* BuyTicket()
{
cout << "买票 -- 全价" << endl;
return nullptr;
}
};
class Student : public Person
{
public:
// 子类中满足三同(函数名、参数、返回值)虚函数，叫做重写(覆盖)
/*virtual B* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}*/
virtual Student* BuyTicket()
{
cout << "买票-半价" << endl;
return nullptr;
}
};
- 析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
// 析构函数是虚函数，是否构成重写？-- 构成
// 析构函数名被特殊处理了，处理成了destructor
class Person {
public:
~Person()
{
cout << "~Person()" << endl;
}
};
class Student : public Person {
public:
~Student()
{
cout << "~Student()" << endl;
}
};
int main()
{
// 普通对象，析构函数是否虚函数,是否完成重写，都正确调用了
/*Person p;
Student s;*/
// 动态申请的对象，如果给了父类指针管理，那么需要析构函数是虚函数
Person* p1 = new Person; // operator new + 构造函数
Person* p2 = new Student;
// 析构函数 + operator delete
//p1->destructor()
delete p1;
delete p2;
// p2->destructor()
return 0;
}
2.5C++11当中的final和override
C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序
写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。1.final修饰的虚函数不能被重写
class Car { public: virtual void Drive() final {} }; class Benz :public Car { public: virtual void Drive() {cout << "Benz-舒适" << endl;} };
- override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错.
class Car{ public: virtual void Drive(){} }; class Benz :public Car { public: virtual void Drive() override {cout << "Benz-舒适" << endl;} };
2.6重写（覆盖），重载，重定义（隐藏）的区别
三、抽象类
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承
class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
int main()
{
Car* c = new Benz;
return 0;
}
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
四、多态的原理
4.1虚函数表
class Base
{
public:
virtual void fun1()
{
cout << "void fun1()" << endl;
}
virtual void fun2()
{
cout << "void fun2()" << endl;
}
private:
int _b = 1;
char _ch = 'A';
};
int main()
{
cout << sizeof(Base) << endl;
Base bb;
return 0;
}
通过观察测试我们发现b对象是12bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。
这里需要注意的是虚函数是在运行时编址
4.2多态的原理
class Person {
public:
virtual void BuyTicket()
{ cout << "买票-全价" << endl; }
void f()
{
cout << "f()" << endl;
}
protected:
int _a = 0;
};
class Student : public Person {
public:
virtual void BuyTicket()
{ cout << "买票-半价" << endl; }
protected:
int _b = 0;
};
void Func(Person& p)
{
// 多态调用，在编译时，不能确定调用的是哪个函数
// 运行时，去p指向对象的虚表中
// 找到虚函数的地址。
p.BuyTicket();
p.f();
}
// 普通函数和虚函数存储的位置是否一样？
// 他们是一样的，都在代码段。只是虚函数要把地址存一到虚表，方便实现多态
int main()
{
Person Mike;
Func(Mike);
Student Johnson;
Func(Johnson);
//Person& r1 = Johnson;
//Person p = Johnson;
//Person p1 = Mike;
//Person p2 = Johnson;
不是多态，编译时确定地址
//p1.BuyTicket();
//p2.BuyTicket();
//Person p1;
//Person p2;
//Student s1;
//Student s2;
return 0;
}
4.2.1单继承的虚函数表
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;
};
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;
Base* p1 = &b;
p1->Func1();
//p1 = &d;
//p1->Func1();
return 0;
}
4.2.2打印虚函数表
//void PrintVFTable(VF_PTR table[])
// 打印虚函数表中内容
void PrintVFTable(VF_PTR* table)
{
for (int i = 0; table[i] != nullptr; ++i)
{
printf("vft[%d]:%p->", i, table[i]);
VF_PTR f = table[i];
f();
}
cout << endl << endl;
}
int main()
{
Base b;
PrintVFTable((VF_PTR*)(*(void**)&b));
Derive d;
PrintVFTable((VF_PTR*)(*(void**)&d));
return 0;
}
4.2.3多继承的虚函数表
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 der;
PrintVFTable((VF_PTR*)(*(void**)&der));
return 0;
}
五、 菱形继承和菱形虚拟继承
class A
{
public:
int _a;
};
//class B : public A
class B : virtual public A
{
public:
virtual void funcB()
{
cout << "void funcB()" << endl;
}
int _b;
};
//class C : public A
class C : virtual public A
{
public:
virtual void funcC()
{
cout << "void funcC()" << endl;
}
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;
d._a = 0;
return 0;
}
结语
希望本篇文章能给各位带来帮助，如有不足还请指正！！！
码字不易，各位大大给个收藏点赞吧！！！
各位大大记得点赞，关注，一键三连哦!!!
