C++系列-多态

🌈个人主页：羽晨同学 

💫个人格言:“成为自己未来的主人~”  

多态

多态就是不同类型的对象，去做同一个行为，但是产生的结果是不同的。

比如说：

都是动物叫声，猫是喵喵，狗是汪汪，它们的叫声是不相同的。

多态的定义和实现

多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

在继承中，构成多态需要两个条件：

1. 必须通过基类的指针或者引用调用虚函数。
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

class Person 
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}
};
class Student:public Person
{//重写/覆盖virtual void BuyTicket(){cout << "买票-半价" << endl;}
};
class Soldier:public Person
{
public://重写/覆盖virtual void BuyTicket(){cout << "买票-优先" << endl;}
};
//多态条件
//1.虚函数重写
//2.父类指针或者引用调用虚函数
void func(Person& p)
{p.BuyTicket();
}
int main()
{Person p;Student st;Soldier so;func(st);func(so);return 0;
}

你看，这样子就实现了多态。

虚函数

被virtual修饰的函数就叫做虚函数

class Student:public Person
{//重写/覆盖virtual void BuyTicket(){cout << "买票-半价" << endl;}
};

虚函数的重写

虚函数的重写（覆盖）：派生类和基类中的某个函数函数名相同，参数相同，返回值相同，就称子类的虚函数重写了基类的虚函数。

class Person 
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}
};
class Student:public Person
{//重写/覆盖virtual void BuyTicket(){cout << "买票-半价" << endl;}
};
class Soldier:public Person
{
public://重写/覆盖virtual void BuyTicket(){cout << "买票-优先" << endl;}
};

你看，这样其实就是标准的构成了函数重写的代码。

但是，由于继承的存在，所以，其实派生类不写virtual也会构成函数重写。

class Person 
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}
};
class Student:public Person
{//重写/覆盖virtual void BuyTicket(){cout << "买票-半价" << endl;}
};
class Soldier:public Person
{
public://重写/覆盖void BuyTicket(){cout << "买票-优先" << endl;}
};

比如上面的这样，但是这样子是不规范的，所以我们最好加上virtual。

虚函数重写的两个例外：

协变（基类和派生类的返回值类型不同）

派生类重写基类虚函数时，与基类虚函数返回值类型不同，即基类虚函数返回基类对象的指针或者引用，派生类对象返回派生类对象的指针或者引用，这个就叫做协变。

class A{};
class B :public A {};class Person 
{
public:virtual A* BuyTicket(){cout << "买票-全价" << endl;return 0;}
};
class Student:public Person
{//重写/覆盖virtual B* BuyTicket(){cout << "买票-半价" << endl;return 0;}
};
class Soldier:public Person
{
public://重写/覆盖virtual B* BuyTicket(){cout << "买票-优先" << endl;return 0;}
};
//多态条件
//1.虚函数重写
//2.父类指针或者引用调用虚函数
void func(Person& p)
{p.BuyTicket();
}
int main()
{Person p;Student st;Soldier so;func(st);func(so);return 0;
}

这样子，我们就实现了协变。

析构函数的重写

我们先来看一下下面的这段代码：

class Person
{
public:virtual ~Person(){cout << "virtual ~Person()" << endl;}
};
class Student:public Person
{
public:protected:int* _ptr = new int[10];
};
int main()
{Person* p1 = new Student;delete p1;return 0;
}

在这段代码当中，我们删除了p1，但是结果调用的是基类的析构函数。

那为什么会这样呢，是因为编译器对析构函数的名字做了特殊的处理，编译后的析构的名字同一处理为了destructor；这样子的话，基类和父类的析构函数就构成了隐藏。

这样子调用的话，那么会造成内存泄漏。

但是，只要我们构成了多态，那么就解决了这个问题。

class Person
{
public:virtual ~Person(){cout << "virtual ~Person()" << endl;}
};
class Student:public Person
{
public:virtual ~Student(){cout << "virtual ~Student()" << endl;}
protected:int* _ptr = new int[10];
};
int main()
{//Student st;Person* p1 = new Student;delete p1;Person* p2 = new Person;delete p2;return 0;
}

override 和final

上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数字母次序写反而无法构成重写，这种错误在编译期间是无法报出的，只有在程序运行时没有到预期结果才会debug，这样子得不偿失。 

final：修饰虚函数，表示该虚函数不能再被重写

class A final
{
public:static A CreatObj(){return A();}
private:A(){};
};
class V:public A
{};
int main()
{A::CreatObj();return 0;
}

所以，在这个代码中，会出现报错的问题。

override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class Car {
public:virtual void Drive() {}
};
class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{Car a;return 0;
}

重载，覆盖（重写），隐藏（重定义）的对比

重载：

两个函数在同一个作用域。

函数名相同，参数不同。

重写（覆盖）

两个函数分别在基类和派生类的作用域。

函数名，参数，返回值都必须相同（协变除外）

两个函数必须是虚函数

重定义

两个函数分别在基类和派生类的作用域

函数名相同

来年各个基类和派生类的同名函数不构成重写就是重定义

抽象类

在虚函数后面写上=0，则这个函数为纯虚函数，包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象，纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
{
public:virtual void Drive() = 0;
};
class Benz :public Car
{
public:virtual void Drive(){cout << "BWM-舒适" << endl;}
};
class BWM :public Car
{
public:virtual void Drive(){cout << "BWM-操控" << endl;}
};
int main()
{Car a;Benz bz;return 0;
}

在这个代码中，因为基类中有纯虚函数，所以不能实例化出对象，而派生类中对纯虚函数进行了重写，所以可以进行实例化。

多态的原理

虚函数表

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
private:int _b = 1;
};
int main()
{cout<<sizeof(Base);return 0;
}

大家可以想一想这个结果是什么。

答案是8，那么，这是为什么呢？

我们来仔细看一下Base里面有什么。

我们可以看到的是在这里面还存在了一个虚函数表的指针，这个就是存放虚函数的地址的地方。

 

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;}
private:int _d = 2;
};
void func1(Base* p)
{p->func1();p->func3();
}
int main()
{Base b;Derive d;func1(&b);func1(&d);return 0;
}

• 通过这个结果，我们可以得到的是，派生类中也有一个虚表的指针，里面存放的有两部分，一个是自己的成员，一个是从基类继承下来的成员。
• 基类b对象和派生类d对象虚表是不一样的，我们这里发现func1完成了重写，所以d中存放的是Derieve::Func1();，所以虚函数的重写也叫覆盖。
• 不是虚函数，函数的指针不会被放进虚表
• 虚表存放在对象里面，虚表里面存放的是虚函数的指针，虚函数存放在代码段那里。

满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象中的找的，不满足多态的函数调用是编译时就确认好的。

动态绑定和静态绑定

在程序编译期间确定了程序的行为，叫做静态绑定。

在程序运行期间，在对象中找的行为，叫做动态绑定

好了，本次的文章就到这里了，我们下次再见。