C++中泛型编程与面向对象编程

1.  面向对象：封装（数据抽象）是基础，继承是手段，多态是目的；泛型编程：参数化类型（概念抽象）是基础，模板是手段，通用是目的
2.  面向对象是运行时问题空间的多态，泛型编程是编译时算法空间的多态
3.  OO以Type为中心，GP以Concept为中心，而Concept完全独立于Type；OO的type是显式定义的，type之间的关系也是显式定义的，是语言支持的 ；GP的Concept是由算法隐式定义的，Concept之间的关系，是无法用目前的C++语法直接表达的；Concept的Model完全可以是毫无关系的Type，refinement独立于inheritence，original concept与其refinement concept的model之间可以毫无关系
4.  以GP写就的算法，自动满足最小接口原则，无需为其参数定义形式化的类型；在OO中，这种形式化的Type具有的操作往往不是所有用到该Type的算法都会用到的
5.  OOP支持二进制组件形式的复用，GP支持源码层级的复用；与二进制码相比较，源码天生具有更多信息和更高级别，所以泛型编程支持更丰富的构件，但其代价是较弱的执行期动态性；你无法通过STL完成CORBA所能完成的功能，反之亦然，两种技术相互补充

——面向对象编程所依赖的多态性称为运行时多态性。
——泛型编程所依赖的多态称为编译时多态性或参数式多态性。

C++中多态分类：
　1）非参数化多态（Ad-hoc polymorphism）：
　　a）函数重载（Function Overloading）
　　b）运算符重载（Operator Overloading）
2）参数化多态（Parametric polymorphism）
　　c）模板（Template）
　
泛型编程的代表就是STL
下面的一个程序是结合了泛型编程与面向对象编程：

View Code

#include <iostream>
#include <vector>
#include <cstdlib>
using  namespace std;
class A{
     public:
    A(){
        cout<<endl;
        cout<< " A  ";
    }
     virtual ~A(){
        cout<< " ~A "<<endl;
    }
     virtual  void kind(){
        cout<< " Type-A "<<endl;
    }
};
class B: public A{
     public:
    B(){
        cout<< " B  ";
    }
     virtual ~B(){
        cout<< " ~B  ";
    }
     void kind(){
        cout<< " Type-B "<<endl;
    }
};
class C: public A{
     public:
    C(){
        cout<< " C  ";
    }
     virtual ~C(){
        cout<< " ~C  ";
    }
     void kind(){
        cout<< " Type-C "<<endl;
    }
};
class D: public A{
     public:
    D(){
        cout<< " D  ";
    }
     virtual ~D(){
        cout<< " ~D  ";
    }
     void kind(){
        cout<< " Type-D "<<endl;
    }
};
int main(){
     int n= 10;
    vector<A*> vec;
    A* pa;
     for( int i= 0;i<n;i++){
         int type=rand()% 4;
         switch(type){
             case  0:
                pa= new A();
                 break;
             case  1:
                pa= new B();
                 break;
             case  2:
                pa= new C();
                 break;
             case  3:
                pa= new D();
                 break;
        }
        vec.push_back(pa);
    }
    vector<A*>::iterator ite;
    cout<<endl;
     for(ite=vec.begin();ite!=vec.end();++ite)
        (*ite)->kind();
     for(ite=vec.begin();ite!=vec.end();++ite)
        delete (*ite);

     return  0;
}

输出如下：

参考：http://blog.csdn.net/wuliaoshengji/article/details/449870