3

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

但是，我有一些代码同时使用了 OO 样式和 Generic 样式，它似乎按我想要的方式工作。

我的问题：

下面的设计是不好的做法。混合多态性和通用代码？

下面我的代码是否有任何坑。（我知道我不应该继承数据成员，但我有：-/）。

#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;
}
4

1 回答 1

4

下面的设计是不好的做法。混合多态性和通用代码？

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

下面我的代码是否有任何坑。

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

其余的我看不到任何直接错误。

如果不知道您要做什么，就不可能说您的设计是否好。

于 2012-07-03T10:10:09.190 回答