类与对象

一、多态

1.1多态基本概念

多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。多态性提供接口与具体实现之间的另一层隔离，从而将“what”和“how”分离开来。多态改善了代码的可读性和组织性，同时也使创建的程序具有可拓展性，项目不仅在最初创建时期可以拓展，而且当项目在需要有新功能时也能拓展。C++支持编译时多态（静态多态）和运行时多态（动态多态），运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。静态多态和动态多态的区别就是函数地址早绑定（静态联编）还是晚绑定（动态联编）。如果函数的调用在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态（编译时多态），就是说地址是早绑定的。如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这就属于晚绑定（动态多态，运行时多态）。

分类：

静态多态（静态联编）：函数的入口地址是在编译阶段确定的（运算符重载、函数重载）
动态多态（动态联编）：函数的入口地址是在运行阶段确定的（虚函数）

1.2向上转型

class Animal{
public:
    void Sleep(void){
        cout<<"动物在睡觉"<<endl;
    }
};
class Cat:public Animal{
public:
    void Sleep(void){
        cout<<"猫在睡觉~~"<<endl;
    }
};
void test01(){
    //用基类指针或引用保存子类对象-->向上转换
    Animal *p = new Cat;
    p->Sleep();//动物在睡觉

    Cat cat;
    //Animal ob = cat;
    Animal &ob = cat;
    ob.Sleep();//动物在睡觉
}

运行结果：

二、虚函数

2.1 引入

需求：用基类指针或引用保存子类对象，同时还要操作子类自身成员

class Animal{
public:
    //虚函数 只要涉及到继承 子类中同名函数都是虚函数 但是我们最好在子类中同名函数加上virtual修饰 便于代码的阅读
    virtual void Sleep(void){
        cout<<"动物在睡觉"<<endl;
    }
};
class Cat:public Animal{
public:
    void Sleep(void){
        cout<<"猫在睡觉~~"<<endl;
    }
};
void test02(){
    Animal *p = new Cat;
    p->Sleep();//猫在睡觉 调用的是子类的Sleep
}

运行结果：

2.2 虚函数不涉及继承

使用virtual修饰成员函数，该成员函数就是虚函数

Animal类的内存布局

vfptr虚函数指针指向的是虚函数表vftable

虚函数表vftable 存放的是vfptr所保存的函数入口地址

class Animal{
public:
    //虚函数本质是一个函数指针变量
    virtual void Sleep(){
        cout<<"动物在睡觉"<<endl;
    }
};
void test01(){
    Animal ob;
    ob.Sleep();
    //如果Animal没有涉及到继承 函数指针变量指向的是自身的Sleep
    //所以调用 动物在睡觉
}

运行结果：

总结：

虚函数本质是一个函数指针变量，如果Animal没有涉及到继承，那么函数指针变量就指向自身的Sleep

2.3 虚函数涉及继承

class Animal{
public:
    virtual void Sleep(){
        cout<<"动物在睡觉"<<endl;
    }
};
class Cat:public Animal{
public:
    void Sleep(){
            cout<<"猫在睡觉~~"<<endl;
    }
};

void test01(){
    Animal ob;
    ob.Sleep();
    //如果Animal没有涉及到继承 函数指针变量指向的是自身的Sleep
    //所以调用 动物在睡觉
}
void test02(){
    Animal *ob = new Cat;
    ob->Sleep();
    //如果Animal涉及到继承 函数指针变量指向的是子类同名函数即Cat的Sleep
    //所以调用 猫在睡觉~~
}

运行结果：

Cat类的内存布局

总结：

当虚函数涉及到继承的时候，子类会继承父类的虚函数指针vfptr和虚函数表vftable，编译器会将继承过来的虚函数表中的函数入口地址更新为子类同名函数（返回值、参数都相同）的入口地址。

如果使用基类指针或引用访问虚函数的时候，就会间接的调用子类的虚函数。

2.4 虚函数的应用

C++动态多态性是通过虚函数来实现的，虚函数允许子类（派生类）重新定义父类（基类）成员函数，而子类（派生类）重新定义父类（基类）虚函数的做法称为覆盖（override），或者称为重写。对于特定的函数进行动态绑定，C++要求在基类中声明这个函数的时候使用virtual关键字，动态绑定也就对virtual函数起作用，为创建一个需要动态绑定的虚成员函数，可以简单在这个函数声明前面加上virtual关键字，定义时候不需要，如果一个函数在基类中被声明为virtual函数，那么在所有派生类中它都是virtual的，在派生类中virtual函数的重定义称为重写（override）。

virtual关键字只能修饰成员函数，构造函数不能为虚函数。

注意：仅需要在基类中声明一个函数为virtual，调用所有匹配基类声明行为的派生类函数都将使用virtual。虽然可以不在派生类声明前使用关键字virtual，但是最好加上，增加代码的可阅读性。

应用案例：基类指针或引用作为函数的参数

与Java一致，向上转型后，如果父类中的方法被子类重写了，通过父类调用的是子类的方法。但是在C++中需要手动将方法设置为virtual，虚函数。

#include <iostream>

using namespace std;
class Animal{
public:
    virtual void Sleep(){
        cout<<"动物在睡觉"<<endl;
    }
};
class Dog:public Animal{
public:
    //重写父类Sleep方法
    virtual void Sleep(){
        cout<<"狗狗在睡觉 汪汪~"<<endl;
    }
};
class Cat:public Animal{
public:
    //重写父类Sleep方法
    virtual void Sleep(){
        cout<<"猫猫在睡觉 喵喵~"<<endl;
    }
};
class Pig:public Animal{
public:
    //重写父类Sleep方法
    virtual void Sleep(){
        cout<<"猪猪在睡觉 吼吼~"<<endl;
    }
};

void fun(Animal &ob){
    ob.Sleep();
}

void fun1(Animal *ob){
    ob->Sleep();
}

int main(int argc, char *argv[])
{
    Dog dog;
    Cat cat;
    Pig pig;
    fun(dog);
    fun(cat);
    fun(pig);
    cout<<"**************"<<endl;
    fun1(new Dog());
    fun1(new Cat);
    fun1(new Pig);
    return 0;
}

运行结果：

这样的话，传入不同的子类就可以调用不同子类对象的方法或者数据。一个函数可以传入不同的类。

一般我们函数都是以基类指针或引用作为函数参数，这样函数可以操作该基类派生出的任意子类对象

2.5 C++如何实现动态绑定

动态绑定什么时候发生？发生的工作都是由编译器在幕后完成的。当我们告诉通过创建一个virtual函数来告诉编译器要进行动态绑定，那么编译器就会根据动态绑定机制来实现我们的要求，不会再执行早绑定。

C++的动态绑定机制是怎么样的？首先我们呢看看编译器如何处理虚函数。当编译器发现我们类中有虚函数的时候，编译器会创建一个虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个指针，这个指针就是vpointer（vptr），这个指针指向对象的虚函数表。在多态调用的时候，根据vptr指针，找到虚函数表来实现动态绑定。（面试中会经常问）