c++ 静态多态与动态多态

多态polymorphism是指具有多种形态的情况，它能根据单一的标记关联不同的行为。多态是面向对象程序设计的基础。在面向对象程序设计中的多态是一种运行时的多态。C++中有两种多态，称为动多态（运行时多态）和静多态（编译时多态），而静多态主要通过模板来实现，宏也是实现静多态的一种途径。其实在做软件设计时静多态的威力也是非常强大的，只不过我们经常对它疏忽了而已。
    动多态的设计思想：对于相关的对象类型，确定它们之间的一个共同功能集，然后在基类中，把这些共同的功能声明为多个公共的虚函数接口。各个子类重写这些虚函数，以完成具体的功能。客户端的代码（操作函数）通过指向基类的引用或指针来操作这些对象，对虚函数的调用会自动绑定到你实际提供的子类对象上去。
    下面以几何对象的设计为例。对各种几何对象如圆、矩形、直线等，都有一些共同的操作，比如画出几何对象，有重心等，我们把这些接口抽象成虚函数放在所谓的抽象基类GeoObj中，具体的几何对象类则继承这个抽象基类。如下：

//dynahier.hpp：几何类的定义
#ifndef __GEOOBJ_H__
#define __GEOOBJ_H__
#include "coord.hpp"
class GeoObj{ //几何对象的公共抽象基类
public:
    virtual void draw() const=; //画出几何对象
    virtual Coord center_of_gravity() const=; //返回几何对象的重心
    //...
};
class Circle : public GeoObj{ //具体的几何对象类：圆
public:
    virtual void draw() const;
    virtual Coord center_of_gravity() const;
    //...
};
class Line : public GeoObj{ //直线类
public:
    virtual void draw() const;
    virtual Coord center_of_gravity() const;
    //...
};
//...
#endif

客户端的使用如下：

//dynapoly.cpp：客户端代码
#include "dynahier.hpp"
#include <vector>
void myDraw(GeoObj const& obj){ //画任意一个GeoObj对象
    obj.draw(); //根据对象类型来调用对应的draw()
}
Coord distance(GeoObj const& x1,GeoObj const& x2){ //计算两个GeoObj对象的重心之间的距离
    Coord c=x1.center_of_gravity()-x2.center_of_gravity();
    return c.abs();  //返回坐标的绝对值
}
void drawElems(std::vector<GeoObj*> const& elems){ //画出属于异类集合的GeoObj对象
    for(std::size_t i=;i<elems.size();++i)
        elems[i]->draw();  //根据元素类型来调用相应的draw()
}
int main(){
    Line l;
    Circle c,c1,c2;
    myDraw(l);  //myDraw(GeoObj&) => Line::draw()
    myDraw(c);  //myDraw(GeoObj&) => Circle::draw()
    distance(c1,c2);  //distance(GeoObj&,GeoObj&)
    distance(l,c);    //distance(GeoObj&,GeoObj&)
    std::vector<GeoObj*> coll; //元素类型互异的集合
    coll.push_back(&l);  //插入一条直线
    coll.push_back(&c);  //插入一个圆
    drawElems(coll);  //画不同种类的GeoObj对象
    return ;
}

静多态的设计思想： 对于相关的对象类型，直接实现它们各自的定义，不需要基类。只是隐式地规定各个具体类的实现中相同功能的接口名要相同。客户端把操作这些对象的函数定义为模板，你需要操作什么类型的对象，直接对模板指定该类型实参即可（或通过实参演绎获得）。
    改写上面的设计，如下：

//statichier.hpp：几何类的定义
#ifndef __GEOOBJ_H__
#define __GEOOBJ_H__
#include "coord.hpp"
class Circle{ //具体的几何对象类Circle，并没有派生自其他类
public:
    void draw() const; //非虚函数
    Coord center_of_gravity() const;
    //...
};
class Line{ //直线类Line
public:
    void draw() const;
    Coord center_of_gravity() const;
    //...
};
//...
#endif

//staticpoly.cpp：客户端代码
#include "statichier.hpp"
#include <vector>
template<typename GeoObj>
void myDraw(GeoObj const& obj){ //画任意一个GeoObj对象
    obj.draw(); //根据对象类型来调用对应的draw()
}
template<typename GeoObj1,typename GeoObj2>
Coord distance(GeoObj1 const& x1,GeoObj2 const& x2){ //计算两个GeoObj对象的重心之间的距离
    Coord c=x1.center_of_gravity()-x2.center_of_gravity();
    return c.abs();  //返回坐标的绝对值
}
template<typename GeoObj>
void drawElems(std::vector<GeoObj> const& elems){ //画出属于异类集合的GeoObj对象
    for(std::size_t i=;i<elems.size();++i)
        elems[i].draw();  //根据元素类型来调用相应的draw()
}
int main(){
    Line l;
    Circle c,c1,c2;
    myDraw(l);  //myDraw<Line>(Line&) => Line::draw()
    myDraw(c);  //myDraw<Circle>(Circle&) => Circle::draw()
    distance(c1,c2);  //distance<Circle,Circle>(Circle&,Circle&)
    distance(l,c);    //distance<Line,Circle>(Line&,Circle&)
    //std::vector<GeoObj*> coll; //错误：异类集合在这里不允许
    std::vector<Line> coll;  //正确：同类集合在这里是允许的
    coll.push_back(l);  //插入一条直线
    drawElems(coll);  //画出所有直线
    return ;
}

两种多态设计范式的比较：
    （1）动多态的特点：通过继承实现、接口预先在基类中确定、是动态的（运行期绑定接口）。
    优点：能处理异类集合（容器中存储基类指针即可）、可执行代码比较小（只需一个多态函数）、可以完全编译而不需要发布源码。
    缺点：不能提前检查类型的安全性（如向容器中插入错误类型的对象）、性能低（有层层继承）、耦合性高（继承的耦合性高于组合）。
    （2）静多态的特点：通过模板实现（宏也是实现静多态的一种途径）、接口没有预先确定而只是隐式地规定、是静态的（编译期绑定接口）。
    优点：具体类可以只实现需要的接口、生成代码性能高（无需通过指针的间接调用，非虚函数具有更多的内联机会）、有更好的类型安全性（类型在编译期就进行检查）、耦合性低（各个类相互独立）、集合的元素类型不再局限于指针。
    缺点：不能处理异类集合、可执行代码比较大（代码膨胀）、模板库源码需要发布、对模板实参类型有约束（比如需要该类型实现了operator<）。
    现实中我们可以组合两种多态来做设计：从公共基类派生不同的子类，从而能够处理属于异类集合的不同对象。而需要操作具体某种类型的对象时，使用模板来实现。
    实际上，泛型程序设计依赖的就是静多态。C++中的一个泛型程序设计杰作就是STL。STL库中的设计思想是把对象的集合抽象为容器，把对对象的操作抽象为算法。算法和容器都是模板（即静多态方案），这样算法可以独立出来，而不是容器的成员函数。一个算法可以被多种容器使用。为了让容器能够使用算法，从容器中抽象出迭代器的概念，通过把容器的迭代器传给算法，就可以在容器上执行算法的行为。
    迭代器是泛型程序设计的粘合剂，它由容器提供并能被算法所使用。迭代器之所以能作粘合剂，是由于容器为迭代器提供了一些特定的接口，而算法所使用的正是这些接口。一般把这样的接口称为concept(即约束)。
    从原则上讲，我们也可以用动多态来实现STL，然而这肯定会带来很多的麻烦。与迭代器的概念相比，动多态的虚函数调用机制将会是一种重量级的实现机制，比如增加一层基于虚函数的接口层，通常这会对性能和效率产生很大的影响，有可能是几个数量级。可见，静多态也是一种威力非常强大的工具，只要应用得好，通过C++的模板，我们可以设计出抽象程度高、性能很好的软件组件。

转自：http://blog.csdn.net/zhoudaxia/article/details/4476056