C++多态

c++中多态分为静态多态和动态多态，在了解他们前，先了解3个相关的概念。

• 函数重载(Overload)：指在相同作用域里(如同一类中)，函数同名不同参，反回值则不用理会，不同参可以是不同个数，也可以是不同类型。

效果：根据实参的个数和类型调用对应的函数体

• 函数覆盖(override)：指派生类中的函数覆盖基类中的同名同参虚函数，因此作用域不同。

效果：基类指针或引用访问虚函数时会根据实例的类型调用对应的函数。

Override实例：

#include <iostream>
#include <string>
using namespace std;
class base
{
public:
        virtual void myname() //1.必须为虚函数
        {
                cout<<"myname is base"<<endl;
        }
};
class derived:public base
{
public:
        void myname() //2.子类必须同名同参
        {
                cout<<"myname is derived"<<endl;
        }
};
int main()
{
        base* bPtr=new derived;
       base* bPtr1=new base;
        bPtr->myname(); //bPtr实际指向子类对象，override调用子类函数
        bPtr1->myname(); // bPtr实际指向基类对象，override调用基类函数
        delete bPtr;
       delete bPtr1;
        return 0;
}
输出：
myname is derived
myname is base

 

函数隐藏(hide): 对于子类中与基数同名的函数，如果不是覆盖(override)那就成了隐藏(hide)。2种情况：
    1.       同名不同参。
       2.       同名同参但基类不是virtual函数。
效果：从对象类逐层上找，调用找到的第一个匹配函数，即基类函数被hide。

Hide与override的区别：Override采用虚表实现，隐藏采用一般函数实现。

静态多态与动态多态

1.     静态多态

静态多态是调用哪个函数是在编译时就确定的。常用函数重载和模板偏特化来实现。

对于传入不同类型参数却使用同一模板的情况，由于使用的是同一个代码段，因此不是多态。但模板和模板偏物化来说，由于不是同样的代码段，因此是多态。

实例：

#include <iostream>

using namespace std;
template<class T>
T add(T a, T b)
{
        cout<<"template is called"<<endl;
        return a+b;
}
template<>
float add(float a, float b)
{
        cout<<"template specialize is invoked for float"<<endl;
        return a+b;
}
int add(int a, int b)
{
        return a+b;
}
double add(double a, double b)
{
        return a+b;
}
int add(int a, int b, int c)
{
        return a+b+c;
}
double add(double a, double b, double c)
{
        return a+b+c;
}
int main()
{
        int i1=11, i2=22, i3=33;
        double d1=1.1, d2=2.2, d3=3.3;
    cout<<hex<<static_cast<int>(add(static_cast<char>(i1),
                          static_cast<char>(i2)))<<endl;
        cout<<"-------------------------------------------"<<endl;
        cout<<dec;
        cout<<add(static_cast<float>(d1), static_cast<float>(d2))<<endl;
        cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
        cout<<"i1+i2="<<add(i1, i2)<<endl;
        cout<<"i1+i2+i3="<<add(i1,i2,i3)<<endl;
        cout<<"++++++++++++++++++++++++++++++++++++++++++++"<<endl;
        cout<<"d1+d2="<<add(d1,d2)<<endl;
        cout<<"d1+d2+d3="<<add(d1,d2,d3)<<endl;
        cout<<"i1+d1="<<add(static_cast<double>(i1),d1)<<endl;
        return 0;
}

输出：

template is called

21

-------------------------------------------

template specialize is invoked for float

3.3

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

i1+i2=33

i1+i2+i3=66

++++++++++++++++++++++++++++++++++++++++++++

d1+d2=3.3

d1+d2+d3=6.6

i1+d1=12.1

运行时多态：

采用覆盖(override)实现，并且使用指针或引用来实现运行时多态，即使用虚函数表实现（参考另一篇虚函数表解析）。