多态是c++中很重要的一环。多态可以分为以下几个层面来剖析：
1.对象的类型
2.多态
3.虚表
先说第一点对象的类型，这个非常简单。比如说、
int a;
那么我就定义了一个int类型的变量a。再来看下面的代码
class Base
{
};
class Derive:public Base
{
};这里我写了一个Base类和一个Derive类，并且Derive类是派生于Base类
Base b; Derive d; Base* pb=&b; pb=&d;
上面的代码实例化了一个Base类类型的对象b，Derive类类型的对象d，Base*类型的指针pb。
pb的静态类型就是Base*类型，我们也可以让pb指向d，Derive*就是pb的动态类型。
下面来说说第二点，多态。
int Add(int left,int right)
{
return left+right;
}
double Add(double left,double right)
{
return left+right;
} 上面这两个函数构成了函数的重载，传进去int类型的参数就调用上面的，double类型的参数就调用下面的。这也是一种多态，称为静态的多态。还有一种泛型编程也是静态的多态。静态多态就是在编译器编译期间完成的，编译器根据函数的实参的类型（可能进行隐式的类型转换），可推断出到底要调用哪个函数，如果有对应的函数就调用该函数，否则就会出现编译错误。
那么动态多态（也叫动态绑定）就是指在程序执行期间判断所引用对象的实际类型，根据其实际类型调用相应的方法。
使用virtual关键字来修饰函数，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定。
所谓虚函数就是指在类中被声明为virtual的成员，基类希望这种成员在派生类中重定义。除了构造函数外，任意非static成员都可以为虚成员。保留字 virtual 只在类内部的成员函数声明中出现，不能用在类定义体外部出现在函数定义上。
看一段代码：
class Base
{
public:
virtual void FunTest()
{
cout<<"Base::FunTest()"<<endl;
}
};
class Derive :public Base
{
public:
void FunTest()
{
cout<<"Derive::FunTest()"<<endl;
}
};
int main()
{
Derive d;
d.FunTest();
Base b;
b.FunTest();
Base *pb=&b;
pb->FunTest();
pb=&d;
pb->FunTest();
return 0;
} 在这一段代码里面，我定义了两个类一个是Base，另一个是他的派生类Derive。Base类里面有一个虚函数FunTest（），Derive类里面也有一个FunTest（）。并且在主函数里面实例化了两个类的对象，并且调用了FunTest函数，下面也定义了Base*类型的指针，先指向b，然后调用了FunTest函数，之后指向d，然后调用FunTest函数。这段代码运行结果会是什么样呢？
正如我们所看到的调用派生类里面的函数他有他就调用他自己的，他没有再去基类里面找。
那么动态绑定实现的条件是什么呢？第一，必须要是虚函数。第二，要通过基类类型的引用或者指针调用。
class CBase
{
public:
virtual void FunTest1(int _iTest)
{
cout << "CBase::FunTest1()" << endl;
}
void FunTest2(int _iTest)
{
cout << "CBase::FunTest2()" << endl;
}
virtual void FunTest3(int _iTest1)
{
cout << "CBase::FunTest3()" << endl;
}
virtual void FunTest4(int _iTest)
{
cout << "CBase::FunTest4()" << endl;
}
};
class CDerive:public CBase
{
public:
virtual void FunTest1(int _iTest)
{
cout << "CDerive::FunTest1()" << endl;
}
virtual void FunTest2(int _iTest)
{
cout << "CDerive::FunTest2()" << endl;
}
void FunTest3(int _iTest1)
{
cout << "CDerive::FunTest3()" << endl;
}
virtual void FunTest4(int _iTest1,int _iTest2)
{
cout << "CDerive::FunTest4()" << endl;
}
};
int main()
{
CBase* pBase = new CDerive;
pBase->FunTest1(0);
pBase->FunTest2(0);
pBase->FunTest3(0);
pBase->FunTest4(0);
return 0;
}上面是一个例子，CBase类是CDerive类的基类。之后FunTest1()是一个虚函数，FunTest2（）不是一个虚函数，FunTest3（）也是虚函数，FunTest4()虽然是虚函数但是在子类里面重新实现给了两个参数。所以运行结果是这样的：
假如我们想调用CDerive里面的FunTest4(),我们就要用CDerive类的对象了。就像下面这样：
CDerive d; d.FunTest4(0, 0);
我们这里有一个图片，能看明白继承体系中同名成员函数的关系：
这里还需要注意：构造函数是不可以定义为虚函数的，因为构造函数是用来构建我们的对象 的，构造函数没有执行完我们的对象就是不完整的。假如我们要调用构造函数，是需要通过我们的基类对象来调用的，但是我们的对象都没有构造完，所以是不能这样的。
静态函数和友元函数也同样不可以用virtual来修饰。因为这两种函数都没有this指针。
这里还有一个东西：
class test
{
virtual void Test() = 0;
}; 这段代码定义的类叫抽象类。它不能够实例化产生对象，它只是提供一些接口。它里面的那个函数后面跟了一个=0，表示它是纯虚函数，它表示它的派生类要对它这个函数进行重写。
最后来说虚表和虚指针。
当我们求sizeof（test）时，我们得出的结果是4。为什么呢？对类求大小的时候不应该是它的成员的大小吗？这里就是有一个虚指针。那这个虚指针指向那里呢？是指向的虚表。虚表里面存的就是虚函数的地址。
举一个例子：
class test
{
public:
virtual void FunTest1()
{}
virtual void FunTest2()
{}
virtual void FunTest3()
{}
virtual void FunTest4()
{}
}; 这个类里面只有四个虚函数，那么sizeof(test)等于多少呢？
再来看看t中到底有什么：
所以当我们要调用虚函数的时候，编译器是先找到我们的虚表地址，之后找到对应的虚函数。
本文出自 “刘子蛋好好学习” 博客，转载请与作者联系！
原文地址：http://lzd1995.blog.51cto.com/10973198/1770468
