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

我有以下等级等级：

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转换为任何其他类型，但我不确定它是否安全，是否是一个好的设计。有什么意见吗？

您最好有一个指向

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

---

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

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

#包括
结构字母
{
浮动m_x；
浮动货币；
};
类基类
{
标准：：唯一性\u ptr数据\uu；
基本信封（常量基本信封&）=删除；
基本信封（基本信封&&）=删除；
公众：
基本信封（）：数据{}；
基本信封（std:：unique_ptr&d）：数据（std:：move（d））{
虚空doA（）=0；
虚空doB（）=0；
无效交换（基本信封&o）{std:：swap（数据，o.data ）}
};
类derived1：公共基_信封
{
公众：
derived1（）：基_信封（）{}
虚空doA（）重写{}
虚空doB（）重写{}
std:：unique_ptrchange_state（）；
};
类derived2：公共基本单元信封
{
公众：
derived2（）：基_信封（）{}
虚空doA（）重写{}
虚空doB（）重写{}
std:：unique_ptrchange_state（）
{
标准：：唯一的ptr<基本信封>r（新衍生的1）；
互换（*r）；
返回std：：move（r）；
}
};
std:：unique_ptrderived1:：change_state（）
{
标准：：唯一的ptr<基本信封>r（新衍生的2）；
互换（*r）；
返回std：：move（r）；
}

这是一种未定义的行为，你不能施放“旁道”，因为它既不安全也不好设计。

DerivedA

和

DerivedB

之间有什么区别？从你的问题听起来，它们是相同的，但是没有理由存在不同的类。你能详细说明它们的区别吗？我恳求你读一本C++的初学者书籍，以及一些面向OOP设计的教程。你想要实现的和你在这里实现的似乎不是C++的方式。这看起来像XY问题。也许你应该让我们知道你想要实现什么。你应该避免原始的指针。值得注意的是，此示例将泄漏第一个

p

。这通常是一种不好的做法。在这种情况下考虑。@ MeZo，你是说你的派生类型存储了<代码> UnQuyPPTR <代码>吗？或者你的意思是通过将“基本”部分包含为成员而绕过继承？请使用

nullptr

-我们不再做那种讨厌的

NULL

宏的事情了。此外，为什么不先用一些有用的东西初始化呢？为什么还要为空赋值而烦恼呢？@FrançoisAndrieux不，我将unique_ptr存储在另一个类中，我们称之为类对象。在类对象中，我想将成员unique_ptr强制转换为指向DerivedA的指针DerivedB@mezo这真是个坏主意，德里维达和德里维达是不同的对象