Question

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

但是，我有一些使用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;
}

Answer 1

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

不，这有时是正确的事情。

下面的代码是否有任何问题。

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

对于其他人，我没有看到任何即时错误。

如果不知道自己想要做什么，就不可能说出你的设计是否合适。

将泛型编程与多态混合

1 个答案: