混合泛型编程和多态

Question

我看过一些关于泛型编程的文章，以及如何永远不要同时使用虚函数和模板。我理解这个习惯用法，因为模板是在编译时决定的，其中虚函数直到运行时才被选择(过度简化)。

然而，我有一些代码将OO风格和泛型风格结合在一起，它似乎能以我想要的方式工作。

我的问题是：

以下是设计上的不良做法。混合多态和泛型代码？

我的代码下面有没有坑掉。(我知道我不应该继承数据成员，但我有:-/)。

#ifndef BaseTemplate_H
#define BaseTemplate_H

#include <vector>

template< class T >
class BaseTemplate {

 public:

  typedef std::vector<T*> pVT;

  BaseTemplate(){}
  virtual ~BaseTemplate(){};
  virtual void Process()=0;
  const pVT& getContainer(){ return m_pContainer; }

 protected:

  pVT m_pContainer;

 private:

  BaseTemplate( const BaseTemplate& cpy );
  BaseTemplate& operator=( const BaseTemplate& rhs);



};

#endif

我首先从基类继承，告诉基模板在继承时我想要什么类型。这将允许我对多个类型进行两次继承，我希望在我的设计中将它们分开。

#ifndef DerClassA_H
#define DerClassA_H

#include <iostream>
#include "BaseTemplate.h"

class DerClassA: public BaseTemplate<int> {

 public:

 DerClassA(){}
 virtual ~DerClassA(){}
 virtual void Process(){
   std::cout << "HELLO I AM: DerClassA" << std::endl;
 }//This will push_back objects to m_pContainer

 private:

 DerClassA( const DerClassA& cpy );
 DerClassA& operator=( const DerClassA& rhs);



};

#endif


#ifndef DerClassB_H
#define DerClassB_H

#include <iostream>
#include "DerClassA.h"

class DerClassB: public DerClassA {

 public:

 DerClassB(){}
 virtual ~DerClassB(){}
 virtual void Process(){
   std::cout << "HELLO I AM: DerClassB" << std::endl;
 }//This will push_back objects to m_pContainer

 private:

  DerClassB( const DerClassB& cpy );
  DerClassB& operator=( const DerClassB& rhs);



};

#endif

#include "DerClassA.h"
#include "DerClassB.h"

int main()
{

  BaseTemplate<int> *pClassA = new DerClassA();
  pClassA->Process();

  DerClassA *pClassB = new DerClassB();
  pClassB->Process();

  delete pClassA;
  delete pClassB;

  return 0;
}

Answer 1

是下面这种设计上的糟糕做法。混合多态和泛型代码？

不，这有时是正确的做法。

在下面的代码中有没有坑掉下来。

• 带有原始指针的容器std::vector<T*> pVT;看起来有点可疑。
• 基类析构函数可能应该是纯虚的。
• 我会使用C++11语法来使基类析构函数只需要使基类析构函数不需要在主函数中进行动态分配。

对于其余的部分，我看不到任何直接的错误。

如果不知道你想做什么，就不可能说你的设计好不好。