c++中相似类型的一种设计方案

问题：假如有一类Object，该类Object会分几种不同类型，不同类型Object之间有相似属性，相似方法，也有不同属性，不同方法；如：

class ObjectA                            

{

    string name;

    string attributeA;

public:

   void MethodA(){}

  void Operation(){};

}

class ObjectB                          

{

    string name;

    string attributeB;

public:

   void MethodB(){}

  void Operation(){};

}

为实现代码重用，减少模块之间的依赖，一般想到的是通过抽取一个基类，其它模块对这些object的操作会通过基类进行；如：

方法一：

class objectbase

{

    string name;

public:

  void Operation(){};

  virtual void MethodA(){}

    virtual void MethodB(){}

}

class ObjectA:piblic objectbase

{

 string attributeA;

public:

virtual void MethodA(){}

}

class ObjectB:piblic objectbase

{

 string attributeB;

public:

virtual void MethodB(){}

}

这样在其它模块中用到ObjectA，ObjectB的地方，只要通过objectbase*来操作即可；

除此之外，还有另外的一种方法，思想是把公共部分抽取出来，通过组合达到目的如：

方法二：

class common

{

    string name;

public:

  void Operation(){};

}

class ObjectA

{

common attibuteCommon;

 string attributeA;

public:

  void Operation(){};

  virtual void MethodA(){}

}

class ObjectB

{

common attibuteCommon;

 string attributeB;

public:

  void Operation(){};

  virtual void MethodB(){}

}

该种方法似乎写的代码要多一些；

还有第三种方法，通过模板机制：

方法三：

class ObjectA

{

 string attributeA;

public:

  void MethodA(){}

}

class ObjectB

{

 string attributeB;

public:

void MethodB(){}

}

template<typename T>

class Object: public T

{

  string name;

public:

  void Operation(){};

}

使用时：Object<ObjectA> A; Object<ObjectB> B

这样实现似乎代码写的要少些（相对于第二种方法），对特定的类不会有多余的方法（相比于第一种方法），但也有缺陷，如不能行第一种方法那样所有类有统一的基类，也就不能把它们放到数组当中；

要实现能放到数组当中，又要代码少，也不会有多余的方法，可采用方法四：

方法四：

class Object

{

}

class ObjectA: public Object

{

 string attributeA;

public:

  void MethodA(){}

}

class ObjectB: public Object

{

 string attributeB;

public:

void MethodB(){}

}

template<typename T>

class Object: public T

{

  string name;

public:

  void Operation(){};

}

可以放到数组当中了，但是使用时似乎的用到向下的类型转换，并且还多了个顶层基类，感觉还是怪怪的；

可采用方法五：

方法五：

template<typename T>

class ObjectA: public T

{

 string attributeA;

public:

  void MethodA(){}

}

template<typename T>

class ObjectB: public T

{

 string attributeB;

public:

void MethodB(){}

}

class common

{

    string name;

public:

  void Operation(){};

}

使用时ObjectA< common> A   ObjectB< common> B

该方法类似第一种方法，只不过用的是模板；