泛型编程杂谈

泛型 (GP)之前, 先谈一下面向对象(OO), OO强调世界是由对象组成的,对象是由方法和属性组成的(个人感觉还应该加上事件),而对象之间又有继承(is-a)和组合等 关系。OO很符合我们认识世界的直觉,它以封装,继承和多态为特性,我们在现实工作中又总结出来了OO的5大设计原则和23种设计模式。总之,OO基本上已经可以很好的解决我们现实生活中的所有问题。

那么既然OO已经可以很好的解决我们的问题了,为什么还要有GP? 

我们先来看一下OO的缺点:
OO的多态是通过继承自同一接口来实现的, 修改接口会导致所有派生类的修改,耦合比较紧密。
OO的多态是运行时的, 性能比较低。
OO的多态通过抽象接口实现,使用不安全,在不支持反射的语言(比如C++)中会丧失类型检测。 

用OO设计时,你只能通过抽象接口来处理不同的事物。比如你要让Cat和Dog同时跑动,你可能会抽象出一个IAnimal接口,内部有一个Run的方法,然后让Cat和Dog分别继承。但是如果你想让猫(Cat)和玩具猫(ToyCat)支持跑动,这时你抽象出IAnimal就不合适了, 你可能会抽象出ICatProperty。可以看到OO的这种继承体系非常笨重,到后面可能会导致非常深的继承层次(比如MFC),代码扩展和维护都很艰难。

上面OO的这些缺点在GP没有被发现之前都不是缺点,因为我们没有更好的解决方案,但是人们逐渐发现了GP,GP最初是在使用容器(Container)时被发现的,container<T>可以放任意类型的元素,根据元素类型,我们可以可以生成任意类型的container. 这些技术后来发展成 泛型 编程和模板元编程。

那么什么是GP?
我的理解是 GP是基于concept的程序设计,我们通过concept来定义对象之间的关系。

什么是concept?
按我的理解,concept就是我们自己定义的概念和规则。

比如说任何对象,只要可赋值,他就符合Assignable的concept:
class  A {};
class  B {};

void  test()
{
   A a1; A a2; a1  =  a2;
   B b1; B b2; b1  =  b2;
}
上面的A和B就都符合Assignable的concept.

又比如任何对象,只要可比较, 他就符合Comparable的concept:
class  C
{
    public :
        bool  operator  <  ( const  C &  c);
        bool  operator  >  ( const  C &  c);
        bool  operator  ==  ( const  C &  c);
        bool  operator  !=  ( const  C &  c);
        bool  operator  <=  ( const  C &  c);
        bool  operator  >=  ( const  C &  c);
};
上面的对象C,他就符合他就符合Comparable的concept。

再看一个例子:
class  Dog 
{
public
    void  run();
};

class  Cat
{
public
    void  run();
};

template < typename T >
void  run(T &  t)
{
    t.run();
}
上面的Cat和Dog就都符合拥有成员函数Run这个concept.

GP的concept可以是任何我们能想到的规则,比如包含某个成员变量,或是定义某个类型, 比如下面代码:
class  myTraits
{
public :
   typedef  int  type;
   type value;
};

template < typename T >
typename T::type GetValue(T &  t)
{
    return  t.value;
}

甚至GP的concept可以是指明基类和派生类, 比如下面代码:

template < typename TDrived, typename TBase >
class  CMyImpl:  public  TBase
{
public :
      void  work()
   { 
      TDrived *  p  =  static_cast < TDrived *> ( this );
      p -> Hello();
     }
};

class  CMyBase {};
class  CMyClass:  public  CMyImpl < CMyClass, CMyBase >
{
public :
      void  Hello() {}
};
ATL中大量应用这种concept来实现代码重用和模拟虚函数。

这些concept在不同语言中定义不一样,在一些语言中(比如C#)我们可以通过定义来进行显式约束,表明我们某个concept要满足哪些条件;在有些语言中(比如C++)则没有这显式约束定义,我们只能通过我们编程时自己的逻辑来保证,当然如果某个方法要求他的对象满足某个concept而你的对象没有满足 ,编译器也是不会让你通过的。

另外GP的concept之间本身也有某种关系, 某个concept可能继承与另外一个concept,或者说某个concept是另外一个concept的强化,也就是满足某个concept的对象肯定也同时满足另外一个concept. 比如concept  A包含Run方法, concept B包含Run和Eat方法,则concept B是concept A的强化,满足concept B的对象肯定同时满足concept A。

我们可以看到GP的这种基于concept的设计方式,大大降低了对象之间的耦合性,我们不再要求象OO那样抽象出共同的接口来让大家继承;任何两个看似没有关系的对象, 只要他们满足某个concept的约束,他们就能当作模板参数传给GP代码(模板类或是模板函数)。另外,我们可以看到GP的这些类型检测是在编译时就完成的,他的多态是在编译时就确定的静多态, 效率大大高于OO的动多态。
 
有些人说GP的抽象能力高于OO,这个观点我并不认同,我感觉只是他们的抽象方式不一样,OO是基于接口, 而GP是基于concept。OO的基于接口的抽象,在源代码和最终运行时都能体现,源代码中是接口,运行时是虚表,所以他们是一致的, 符合普通人的思维习惯。GP基于concept的抽象, 主要体现在源代码中 ,只是你用来告诉编译器你的思维方式, 在运行时他可能是一个完全不同的世界,所以比较难理解。

如果说OO的设计是抽象出接口, GP的设计就是抽象出concept, 满足某个concept的class是一个template class(如template<typename T> class vector), 而template class的又可以实例化成某个特定的class(如vector<int>)。 所以GP可以大大减少我们源代码的数量,但是他本身不能减小我们最终编译的可执行文件的大小,相反如果模板类过大,反而会造成代码膨胀,而OO的继承则没有这个问题(可参考 C++模板会使代码膨胀吗 )。

对于在实际开发中主要用OO还是用GP的问题, 可能应人和公司而异,最好的方式当然是OO和GP的灵活结合。有人觉得GP的代码不好理解,那是因为你没有理解他的concept,比如看了《 泛型 编程与STL》,你就会发现自己也可以扩展STL了。当然,因为C++对concept没有约束定义机制, 而concept这个东西注释又不好描述,所以大部分时候我们只能通过源代码来推理,这在一定程度上也造成了GP代码难读懂这种说法的流行。

不知道大家在实际开发中GP用的多不多?

你可能感兴趣的:(编程)