多态，覆盖，重载，静态联编，动态联编。

多态：

C++多态有两种形式，动态多态和静态多态。

动态多态是指一般的多态，是通过类继承和虚函数机制实现的多态；

静态多态是通过模板方法来实现，因为这种多态是在编译时而非运行时，所以称为静态多态。

动态多态例子：

class CShape
{
 public:
 CShape(){}
 virtual ~CShape(){}

 virtual void Draw() = 0;
};
class CPoint : public CShape
{
public:
 CPoint(){}
 ~CPoint(){}
 void Draw()
 {
   printf("Hello! I am Point!/n");
 }
};
class CLine : public CShape
{
  public:
 CLine(){}
 ~CLine(){}

 void Draw()//覆盖
 {
  printf("Hello! I am Line!/n");
 }
};
void main()
{
 CShape* shape = new CPoint();//父类指针指向子类对象
 //draw point
 shape->Draw();//在这里shape将会调用CPoint的Draw()函数
 delete shape;

 shape = new CLine();
 //draw Line
 shape->Draw();//而在这里shape将会调用CLIne 的Draw()函数
 delete shape;
 return ;
}

由上面的例子，大家应该能理解什么是多态了：也就是一个Draw（） 可以有两种实现，并且是在运行时决定的，在编译阶段不知道，也不可能知道！只有在运行的时候才能知道我们生成的shape是那种图形，当然要实现这种效果就需要动态联编了，在基类我们会把想要多态的函数声明为虚函数，而虚函数的实现原理就使用了动态联编。

一个静态多态的例子：

在上面例子的基础之上添加模板函数：

template <class T>
void DrawShape(T* t)
{
 t->Draw();
}
修改main函数为如下：
void main()
{
 CShape* shape = new CPoint();
 //draw point
 shape->Draw();

 DrawShape<CPoint>((CPoint*)shape);
 delete shape;

 shape = new CLine();
 //draw Line
 shape->Draw();
 DrawShape<CLine>((CLine*)shape);
 delete shape; 
 return ;
}

在程序编译main函数的时候，编译器就已经指定了DrawShape函数里面的Draw要调用那个实现了，这就是静态多态，在编译时就已经知道了要调用的函数。

静态联编和动态联编:（这里的例子对吗？）

静态联编是指在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于指向对象的指针（或者引用）的类型，C语言中，所有的联编都是静态联编,据我所知道的，任何一种编译器都支持静态联编（废话）。

动态联编是指在程序执行的时候才将函数实现和函数调用关联，因此也叫运行时绑定或者晚绑定，动态联编对函数的选择不是基于指针或者引用，而是基于对象类型，不同的对象类型将做出不同的编译结果。C++中一般情况下联编也是静态联编，但是一旦涉及到多态和虚拟函数就必须要使用动态联编了

一个静态联编的例子：

class shape{
  public:
    void draw(){cout<<"I am shape"<<endl;}
    void fun(){draw();}
};
class circle:public shape{
  public:
    void draw(){cout<<"I am circle"<<endl;}
};
void main(){
    circle  oneshape;
    oneshape.fun();
}

修改为动态联编的例子：

class shape
{
  public:
  virtual void draw(){cout<<"I am shape"<<endl;}
}; 
 void fun(shape *ptr)
 {ptr->draw();}

class circle:public shape
{
  public:
    void draw(){cout<<"I am circle"<<endl;}
 };
int main()
{
     circle  oneshape,*p;
    p=&oneshape;
    fun(p);

   return 0;
}

覆盖、重载、多态

覆盖：在基类中定义了一个非虚函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。在派生类对象上直接调用这个函数名，只会调用派生类中的那个。

重载：在基类中定义了一个非虚函数，然后在派生类中定义一个同名，但是具有不同的参数表的函数，这就是重载。在派生类对象上调用这几个函数时，用不同的参数会调用到不同的函数，有可能会直接调用到基类中的那个。

多态：在基类中定义了一个虚函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声类中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。