【C++】多态概念(入门)

介绍：

        多态的概念：通俗来说，多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。比如扫红包操作，同样是扫码动作，不同的用户扫 得到的不一样的红包，这就是一种多态行为。

多态的构成条件

        首先，我们先来认识一下虚函数。在类中，被virtual修饰的类成员函数称为虚函数。如下;

class Person {
public:
    virtual void BuyTicket()  //虚函数

    {

        cout << "买票-全价" << endl;

    }
};

        多态的构成需要两个条件：1，必须通过基类的指针或者引用调用虚函数，这时传入的是父类调用的是父类虚函数，传入的是子类调用的是子类的虚函数。2，被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(重写：派生类中有一个跟基类完全相同的虚函数，即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表完全相同，称子类的虚函数重写了基类的虚函数)。

        注意：多态中，派生类的virtual写不写都可以，但是基类的virtual必须写上。

#include <iostream>
using namespace std;
class Person 
{
public:
    virtual void BuyTicket() 
    {
        cout << "买票-全价" << endl; 
    }
};
class Student : public Person 
{
public:
    virtual void BuyTicket() 
    {
        cout << "买票-半价" << endl;
    }
    /*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用,如以下*/
   /*void BuyTicket() { cout << "买票-半价" << endl; }*/

   //注意：基类无论在什么情况下若不加virtual就无法构成重写，也就说基类必须写上virtual
};
void Func(Person& p)  //通过基类Person引用调用虚函数
{
    p.BuyTicket();
}
void Func2(Person p)  
{
    p.BuyTicket();
}
int main()
{
    Person ps;
    Student st;
    Func(ps);
    Func(st);
    cout << endl;
    //下面的调用将全部调用基类的函数
    Func2(ps);
    Func2(st); 
    return 0;
}

        总的来说在继承体系中存在两种调用：普通调用和多态调用

                普通调用：系统看的是指针或引用或对象本身的类型。   

                多态调用：系统看的是具体指向的对象，即指向子类调子类，指向父类调父类。

虚函数重写的两个例外

1，协变：基类与派生类虚函数返回值类型不同，但这里返回值必须要求是父子类关系的指针或引用。（协变本身没有意义，这里只需了解即可）

#include <iostream>
using namespace std;
class A 
{    };
class B : public A
{    };
class Person {
public:
    virtual A* f() {
        cout << "Person A::f()" << endl;
        return new A; 
    }
    void fun()
    {
        cout << "class Person" << endl;
    }
};
class Student : public Person {
public:
    virtual B* f() {
        cout << "Student B::f()" << endl;
        return new B;
    }
    void fun()
    {
        cout << "class Student" << endl;
    }
};

int main()
{
    Person* p = new Student; 
    p->f(); //调用子类Student函数，即多态协变
    p->fun();  //调用父类Person函数，即继承赋值转换，不是隐藏
    Person p1;
    Student s;
    p1 = s;
    p1.fun();  //同理，调用父类Person函数
    return 0;
}

2. 析构函数的重写(基类与派生类析构函数的名字不同)

        继承体系中，基类与派生类的析构函数中存在问题。比如当我们使用基类指针指向派生类地址空间时，由于指针指向的是派生类中基类的地址，所以这里结束时默认调用基类析构函数，不会调用派生类析构函数，这将会导致派生类中部分空间没有释放，导致内存泄漏问题。因此，这里需使用虚函数，使其调用派生类的析构函数。

        如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字， 都与基类的析构函数构成重写，这里是特殊情况，这里可以理解为编译器对析构函数的名称做了特殊处理。

#include <iostream>
using namespace std;
class Person {
public:
    virtual ~Person() { 
        cout << "~Person()" << endl;
    }
};
class Student : public Person {
public:
     virtual ~Student() { 
        cout << "~Student()" << endl;
    }
};

int main()
{
    // 析构函数在没有加virtual关键字前，下面的两次清理空间都调用Person的析构函数。
    Person* p1 = new Person;
    delete p1;
    //在没有加上virtual前，开辟派生类Student空间中的析构函数没有调用,即派生类中部分空间没有清理，可能会导致内存泄漏
    //加上virtual后，将会调用指向对象的析构函数，即子类Student的析构函数，之后会调用基类Person的析构函数
    Person* p2 = new Student; 
    delete p2;
    return 0;
}

C++11标准的override和final

1，final：它即可修饰虚函数，表示该虚函数不能再被重写，也可修饰类，表示此类不能被继承

#include <iostream>
using namespace std;

class A final
{
public:
    A()
    {    }
};
class B : public A //直接报错，final修饰的类不可被继承
{
public:
    B()
    {    }
};

class A
{
public:
    virtual void Drive() final 
    {    }
};
class B : public A
{
public:
    virtual void Drive() { //基类Drive虚函数加上final，不能被重写
        cout << "B" << endl;
    }
};

        说到这里，要想父类不被子类继承，除了使用final关键字外，只需将父类的构造函数私有化，使子类实例不出对象即可。

class A
{
private:
    A()
    {    }
};
class B : public A
{
public:
    B()  //在子类B中不能调用父类A的构造函数，即不能被继承
    {    } 
};

2，override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。此关键字通常用来检查重写有没有问题。

#include <iostream>
using namespace std;
class A {
public:
    virtual void Drive() 
    {    }
    void test()
    {    }
};
class B : public A {
public:
    virtual void Drive() override { 
        cout << "B" << endl;
    }
    virtual void test() override { //没有重写基类虚函数，报错

    }
};
int main()
{
    A a;
    B b;
    return 0;
}

        最后，我们总结重载、重写和隐藏。三者关系非常紧密，如下图:

        在多态中，这里还有很多注意点，我们先以下面代码的典型例子来分析多态的运用。

#include <iostream>
using namespace std;
class A
{
public:
    virtual void func(int val = 1) { 
        cout << "A->" << val << endl;
    }
    virtual void test() { 
        func();  //这里通过this指针调用func，但这里属于多态调用，指向是对象是子类，所以会调用子类func
        //注意：val的数值为1是因为这里可看成基类声明func，子类定义func
    }
};
class B : public A
{
public:
    void func(int val = 0) {
        cout << "B->" << val << endl; 
    }
};
int main()
{
    B* p = new B;
    B b;
    //下面两次都输出B->1
    b.test(); 
    p->test();
    return 0;
}

         我们知道，在重写中，只要派生类写上virtual，基类可不用写virtual，这是因为virtual关键字的主要目的是在基类中标记一个函数，以便在派生类中可以重写它以实现多态性。在以上代码逻辑中，这里可看成基类实现虚函数的声明，派生类实现虚函数的定义。因此val的数值为1。