8、多态与继承

1、多态

    多态是通过虚函数来实现的，也就是说虚函数是允许子类重新定义成员函数，而子类通过定义和父类一样的函数的方法，被成为覆盖或者是重写。

    多态的作用，使得代码可以重用，代码模块化；

函数重写：

    （1）子类定义的函数与父类原型相同的函数

    （2）函数的重写只有发生在父类和子类之间

class Parent 
{
public:
    void f()
    {
        cout << "Parent" << endl;
    }
};
class Child : public Parent
{
public:
    void f()
    {
        cout << "Child" << endl;
    }
};
int main()
{
    Child c1;
    c1.f();
    while (1);
}
 

    打印出子类的同名函数：Child，除非使用 c1.Parent::f(); 才会执行 父类的打印函数，一般的情况是，编译器会将父类的打印函数进行隐藏，使用的是子函数重写的函数去执行，

void run()
{
    Child c1;
    c1.f();
    Parent *pp = &c1;
    pp->f(); // 父类的打印
    Parent &ppp = c1;
    ppp.f(); // 父类的打印
}
int main()
{
    run();
    while (1);
}

打印出来：

Child
Parent
Parent

    打印结果，居然和分析不一样，原因是：C和C++是静态编译型语言（编译器会根据指针的类型去判断执行的是一个什么用的对象），所以，我们的指针和引用的是 是 Parent，所以执行的时候，输出的结果是父类的打印函数。言而总之，总而言之，我们就看指针，指针是什么类型。

多态的本质：

    通过添加 virtual 关键字对多态进行支持，将会被子类进行重写的函数，前面加上 virtual 关键字，

class Parent 
{
public:
    virtual void f()
    {
        cout << "Parent" << endl;
    }
};
class Child : public Parent
{
public:
    virtual void f()
    {
        cout << "Child" << endl;
    }
};
void run()
{
    Child c1;
    c1.f();
    Parent *pp = &c1;
    pp->f();
    Parent &ppp = c1;
    ppp.f();
}
这三个打印输出的就是： child child child

    只要在会被进行函数重写的函数假如 virtual 关键字，那么这个函数就是虚函数，到具体使用的时候，就会根据实际的情况进行打印输出。传入的是什么类型的，打印的就是什么类型的。

重载和重写的区别：什么时候重载、什么时候重写

    （1）重载：

    A 是同时存在多个同名的函数，但是在参数的个数，参数的类型、参数的顺序存在区别，

    B 事实上，重载只能发生在一个类里面，继承是不能实现函数的重载。

    C 原理上，C++编译器根据参数的不同，重新生成函数名，所以不同的参数会生成不同的函数名，所以本质上就是不同的函数了，也就是说编译器在编译的时候，就已经可以区分到底调用的是哪一个重载的函数，编译器早早已经确定，这些函数的编译的时候的地址就已经是被绑定了（早绑定）。

    （2）重写：

    A 是指子类重新定义父类的虚函数。子类重新定义了父类的虚函数，

     B 必须是发生在父类和子类之间。 父类和子类中的函数，必须完全相同的原型

    C 使用 virtual 可以产生多态

    D 多态是在运行的期间跟根据具体的对象的类型决定调用函数。

将所有的函数都加上 virtual 关键字：

    完全没有必要，这就涉及到虚函数的实现编译器将包含了 virtual 的虚函数的函数信息，存放到虚函数表里面，每次运行的时候，都会去虚函数表里面进行比对，看看是不是虚函数，如果是的话，那么就使用虚函数表里面的函数，不是的话，就去运行类内部其他的函数，所以不要将所有的函数全部设置为虚函数，会造成大量的浪费，处于效率考虑的话，其实就不要全部设置为虚函数。

纯虚函数：

    是一种特殊的虚函数，在基类中（父类）不能对虚函数给据有意义的实现，而把他声明为纯虚函数，它的实现则留给子类去做，这就是纯虚函数的作用，

    纯虚函数在父类只做函数原型的声明，而故意不定义函数体的虚函数，函数的定义等子类去完成（必须），这样就完成了纯虚函数的作用。

class Shape 
{
public: // 纯虚函数声明，没有实际的意义
    virtual double area() = 0;
};
class Rectangle : public Shape
{
    double a;
    double b;
public:
    Rectangle(double a, double b)
    {
        this->a = a;
        this->b = b;
    }
    // 函数的重写，纯虚函数重写
    double area()
    {
        return a * b;
    }
    
};
void area(Shape *s)
{
    cout << s->area() << endl;
}
void run()
{
    Rectangle rectangle(3, 4);
    cout<<"area is "<<rectangle.area()<<endl;
    area(&rectangle); // 可以使用指针
    //Shape shape; // 不能定义抽象类
}

   看到纯虚函数的声明是，virtual 函数 = 0； 告诉编译器，这个只是声明，所以必须在子类去实现这个函数；注意到： 抽象类（shape，包含了一个纯虚函数的类）已经是不能定义对象了，但是仍然可以使用指针。

注意：

    不要将多态应用于数组当中，

多重继承：

    多重继承就是 子类既继承自父类1，同时也继承父类2。实际的应用中，是不使用多重继承，