Question

我有以下课程：

class Base
{
public:
    virtual void DoA();
    virtual void DoB();
    virtual void DoC();

protected:
    float m_x;
    float m_y;
};

class DerivedA : public Base
{
public:
    virtual void DoA() override;
    virtual void DoB() override;
    virtual void DoC() override;
};

class DerivedB : public Base
{
public:
    virtual void DoA() override;
    virtual void DoB() override;
    virtual void DoC() override;
};

所有方法DoA(), DoB() ...仅对基类成员起作用，其中一些可能会在其中调用基类方法。在运行时，我创建了DerivedA类型的对象作为默认值，但我可能需要将其更改为DerivedB或DerivedC。但是我发现通过复制DerivedA的状态并再次初始化它来创建这些对象毫无用处。我认为解决方案可能是将DerivedA转换为任何其他类型，但我不确定它是否安全以及它是否是一个好的设计。有什么意见吗？

Answer 1

您给出的示例听起来像是在尝试开发某种状态机，其中不同的派生类是不同的状态。这通常通过使用字母/信封惯用语来处理，其中信封是不同的状态，并且字母包含公共数据。

#include <memory>
struct letter
{
   float m_x;
   float m_y;
};
class base_envelope
{
   std::unique_ptr< letter > data_;
   base_envelope( const base_envelope & ) = delete;
   base_envelope( base_envelope && ) = delete;
public:
   base_envelope(): data_() {};
   base_envelope( std::unique_ptr< letter > & d ): data_(std::move(d)) {}
   virtual void doA() = 0;
   virtual void doB() = 0;
   void swap( base_envelope & o ) { std::swap( data_, o.data_ ); }
};
class derived1: public base_envelope
{
public:
   derived1(): base_envelope() {}

   virtual void doA() override { }
   virtual void doB() override { }
   std::unique_ptr< base_envelope > change_state();
};

class derived2: public base_envelope
{
public:
   derived2(): base_envelope() {}

   virtual void doA() override {}
   virtual void doB() override {}
   std::unique_ptr< base_envelope > change_state()
   {
     std::unique_ptr< base_envelope > r( new derived1 );
     swap( *r );
     return std::move( r );
   }
};

std::unique_ptr< base_envelope > derived1::change_state()
{
  std::unique_ptr< base_envelope > r( new derived2 );
  swap( *r );
  return std::move( r );
}

Answer 2

您最好有一个指向Base类的指针，并在需要时创建并分配派生类的对象：

Base * p = NULL;
// some code ...
p = new DerivedA;
p->DoA(); // DoA from DerivedA class
// some code ...
p = new DerivedB;
p->DoA(); // DoA from DerivedB class

调用不同派生类的虚方法而不实例化

2 个答案: