一种不好的设计大家来论论

class Base
{
   Type GetType()
  {
    return Type.Base;
  }   
}

Class DeriveClassA : Base
{
   Type GetType()
   {
      return Type.DeriveClassA;
   }
   public void AFounction()
   {
       // do sthing...
   }
}

Class DeriveClassB : Base
{
   Type GetType()
   {
      return Type.DeriveClassB;
   }
   public void BFounction()
   {
      // do anther sthing
   }
}

enum Type
{
    Base,
    DeriveClassA,
    DeriveClassB
}
从OO来看这不是一个好的设计，因为Base知道Type枚举，从而增加一个新的子类就会修改Enum Type,从而导致Base重新编译，从而导致所有的子类重新编译。然而如果从修改的角度上来看，似乎没有什么大的修改，仅仅是需要重新编译一遍。好处是，每个类都知道自己是什么类型。使用的时候
void Fountion(const Base& myclass)
{
   switch(myclass.GetType())
   {
      case Base:
          // dosth....
          break;
      case DeriveClassA:
          // castdown DeriveClassA,然后执行DeriveClassA特有的方法AFounction
          break;
      case DeriveClassB:
          // castdown DeriveClassB,然后执行DeriveClassB特有的方法BFounction
          break;
      default:
          break;
   }
}
如果这样的话，那么好，一个疯狂的想法，不管什么类都可以从一个这样的base class派生，然后GetType，然后castdown，但这很糟糕。没有任何复用价值，而且enum很难维护。但这里是对一系列is-a关系的类采用这个方法。
用户使用没有透明度，但是用户要知道AFounction和BFounction必须知道DeriveClassA和DeriveClassB，归根到底是接口设计不当，最好是让用户只知道接口(Base)，而不知道他的实现。 -___-