Question

我有两个B和C类（都来自A类）一个名为H的类，它包含A或B.

代码：

class A  // abstract base class
{
  // bells and whistles
  // virtual fn 
     void fn() = 0 ; 
     protected:
         // some variables common to B and C
};

class B : public A  // inherit from A...
{
      B();
      fn(); // implement virtual function
      // bells and whistles
};

B::B() :A()
{
 // things
}

void B::fn()
{
 // things
}

// Class C : exactly the same as class B 


// Class H : holds B or C 
enum class CLASS_TYPE { TYPE_B, TYPE_C }

class H
{
   public:
      H(CLASS_TYPE type_);
      ~H();
   private: 
      A * _obj; 

};


H::H(CLASS_TYPE type_)
{
     switch(type_)
     {
     case CLASS_TYPE::B:
          _obj = new B();
          break;
     case CLASS_TYPE::C:
          _obj = new C();
          break;
     }
}

H::~H()
{
    delete _obj;// delete allocated object 
}

这是基于构造函数中的参数在类中创建内部对象的正确方法吗？也是使用抽象基类，虚拟高效？这是大规模模拟程序的一部分，我想避免性能损失。

谢谢。 PS：我试图保持简单，如果需要更多信息请告诉我。

Answer 1

这是基于构造函数中的参数在类中创建内部对象的正确方法吗？

我的第一个倾向是摆脱enum。让类的用户构造一个对象并使用它来构造H。

将virtual成员函数clone()添加到A。

更改构造函数以接受A const&。使用clone()成员函数在构造函数中创建输入对象的副本。

将H中的成员变量更改为std::unique_ptr而不是原始指针。

这是我的建议：

class A 
{
   public:
      virtual A* clone() const = 0;
      virtual void fn() = 0 ; 
   protected:
};

class B : public A
{
   public:

      virtual A* clone() const
      {
         return new B;
      }

      B();
      virtual void fn();
};

B::B() : A()
{
}

void B::fn()
{
}

#include <memory> // of std::unique_ptr
class H
{
   public:

      H(A const& a);

      // No need to have an explicit destructor.
      // The compiler generated destructor will do just fine.
      // ~H();

   private: 
      std::unique_ptr<A> aPtr_;
};

H::H(A const& a) : aPtr_(a.clone())
{
}

Answer 2

你需要

virtual void fn() = 0 ;

中的

和

void fn() override;  // note: override is not strictly need but good practice

在B级和C级

此外，您必须处理复制和分配，因为您在课程中有一个原始指针。直接逐个成员的副本将导致两个H对象指向同一个B / C.这将是非常糟糕的。因此，为了安全起见，您应该删除默认生成的副本/作业。更好的方法是尽可能避免使用原始指针。

虚拟功能（多态）的性能成本很低。另请参阅 Cost of Polymorphic calls - C++

根据构造函数中的参数创建内部对象？

2 个答案: