关于多态

多态基本概念

顾名思义就是多种形态，多种状态。

分类

静态多态

编译器在编译期间完成的，编译器根据函数实参的类型（可能会进行隐式类型的转换），可推断出要调用哪一个函数，如果有对应的函数就调用该函数，否则出现编译错误。

#include<iostream>
#include<stdlib.h>
using namespace std;
class C
{
public:
    int fun(int x,int y,int z)
    {
        cout<< x + y + z<<endl;
        return 0;
    }
    int fun(int s)
    {
        cout<<s<<endl;
        return 0;
    }
};
void test()
{
    C a;
    a.fun(1, 2, 3);
    a.fun(4);
}

可以看到，在C类里面两个fun()构成了重载，作用域函数名都一样，参数个数不一样，而在test()里面，通过C类的对象调用两个fun()的时候，可以通过参数决定调用哪个fun(),这里就实现了静态多态。

动态多态

1：首先了解什么叫做虚函数

class A
{
public:
     void funtest1()
    {
        cout << "A.funtest1" << endl;
    }
};
class B: public A
{
public:
    void funtest1()
    {
        cout << "B.funtest1" << endl;
    }
};
void fun(A &s)
{
    s.funtest1();
}
int main()
{
    A d;
    fun(d);
    B c;
    fun(c);
    system("pause");
    return 0;
}

在上面的代码里面，fun(A &s)的参数是基类的引用，而在主函数里面不论用基类的对象还是派生类的对象去调用fun函数时，所执行的都是基类中的成员函数，而我们期望的是当我们用派生类对象调用fun函数时会执行派生类的成员函数，这里就需要虚函数的帮助来实现。那么，什么是虚函数呢？

虚函数

在类的声明中被加上virtual关键字修饰的成员函数。虚函数可以实现动态多态，在派生类中进行重写。

#include<iostream>
#include<stdlib.h>
using namespace std;
class A
{
public:
     virtual void funtest1()
    {
        cout << "A.funtest1" << endl;
    }
};
class B: public A
{
public:
    virtual void funtest1()
    {
        cout << "B.funtest1" << endl;
    }
};
void fun(A &s)
{
    s.funtest1();
}
int main()
{
    A d;
    fun(d);
    B c;
    fun(c);
    system("pause");
    return 0;
}

可以看出，通过虚函数便可以实现用实际传参来决定执行哪一个类的成员函数，也就是动态多态。

动态多态具体概念

当一个函数如上例中func()函数那样以基类对象引用（或基类对象指针）做参数时，调用该函数时给的实际参数可以是基类的对象也可以是派生类的对象（或对象地址），这时希望在运行函数时根据实际参数的类型来决定是调用基类的还是派生类的成员函数（该函数在基类与派生类中原型相同），这种情况称为动态多态。

c++中如何实现多态

1：在继承体系下，基类必须有虚函数。
2：派生类必须对基类的虚函数进行重写。

继承体系中同名函数的关系

什么叫协变?
协变：与重写条件基本相同，唯一不同协变的返回值不同，基类返回基类指针或引用，派生类返回派生类的指针或引用。

纯虚函数

在成员函数的形参后面写上=0.则成员函数为纯虚函数。

#include<iostream>
#include<stdlib.h>
using namespace std;
class A    //抽象类
{
public:
    virtual void funtest1() = 0   //纯虚函数
    {
        cout << "A.funtest1" << endl;
    }
};
class B: public A
{
public:
    virtual void funtest1()
    {
        cout << "B.funtest1" << endl;
    }
};
void fun(A &s)
{
    s.funtest1();
}
int main()
{
    A d;
    fun(d);
    B c;
    fun(c);
    system("pause");
    return 0;
}

对上面这段代码进行变异发现编译器会报如上图所表示的错误，那么就又有一个概念叫做抽象类，

抽象类

含有纯虚函数的类叫做抽象类，抽象类是不能实例出对象的。纯虚函数在派生类中重新定义以后，派生类才能实例出对象。

#include<iostream>
#include<stdlib.h>
using namespace std;
class A    //抽象类
{
public:
    virtual void funtest1() = 0   //纯虚函数
    {
        cout << "A.funtest1" << endl;
    }
};
class B: public A
{
public:
    virtual void funtest1()
    {
        cout << "B.funtest1" << endl;
    }
};
void fun(A &s)
{
    s.funtest1();
}
int main()
{
    B c;
    fun(c);
    system("pause");
    return 0;
}

可以看到在派生类B中对纯虚函数重写以后是可以实例出对象的，通过编译完全没问题。
总结：
1、派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同。(协变除外)
2、基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。
3、只有类的非静态成员函数才能定义为虚函数，静态成员函数不能定义为虚函数。
4、如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时不用加。
5、构造函数不能定义为虚函数，虽然可以将operator=定义为虚函数，但最好不要这么做，使用时容易混淆6、不要在构造函数和析构函数中调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会出现未定义的行为。7、最好将基类的析构函数声明为虚函数。(析构函数比较特殊，因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理)。
8、虚表是所有类对象实例共用的。