C++ STL 容器中的多态性

Question

我想知道是否存在解决此问题的优雅解决方案。

假设如下：

class Base {
  private:
    int data;
  protected:
    Base(int data) : data(data) { }
    int getData() const { return data; }
    virtual bool someOp() = 0;
}

class Derived1 : public Base {
  private:
    int data2;
  public:
    Derived1(int data, int data2) : Base(data), data2(data2) { }
    int getData2() const { return data2; }
    bool someOp() override { /* something */ }
}

class Derived2 : public Base {
  private:
    float data2;
  public:
    Derived1(int data, float data2) : Base(data), data2(data2) { }
    float getData2() const { return data2; }
    bool someOp() override { /* something */ }
}

并且假设我可以完全控制层次结构，所以我可以假设 Base 不会扩展，也不会扩展任何 DerivedX class.

现在我想将它们存储在 std::vector 中，如果我想使用多态性，我不得不存储指针，否则对象切片将阻止我存储额外的派生属性。所以我基本上被迫使用 std::vector<unique_ptr<Base>>.

但是假设我需要存储大量这些对象并且我不想浪费双堆分配（内部 std::vector + 对象本身）并且同时我可以假设：

class层次结构定义完美，不会在不知不觉中扩展
sizeof(DerivedX) 不会比 sizeof(Base)

所以我想知道是否有一种优雅的方法来保持多态性并避免存储指针。我可以想到一些解决方案，例如

class Base {
  enum {
   DERIVED1,
   DERIVED2
  } type;

  int data;
  union {
    int derived1data;
    float derived2data;
  }

  bool someOp() {
    if (this->type == DERIVED1) ...
    else if ..
  }
}

但这显然不优雅。我还可以尝试利用 sizeof(Derived) == sizeof(Base) 时不应发生对象切片这一事实，方法是在 Base 中使用受保护的联合并从 Derived 访问它并将地址转换为 [= 中的元素=14=] 到所需的类型（根据枚举）但这听起来也很难看。

Answer 1

类型擦除和小缓冲区优化。

您几乎可以在 C++ 中键入擦除任何属性，创建自定义界面，"knows" 如何将属性应用于现在未知的类型。

boost::any type erases down to copy, destroy, get typeid, and cast-back-to-exactly-matching-type。 std::function type erases down to copy, invoke with a specific signature, destroy, and cast-back-to-identical-type（最后一个很少使用）。

基于免费存储的类型擦除实现通过交换指针获得移动语义'for free'。

在您的情况下，您需要在类型中创建一个 "large enough" 对齐存储。您需要键入 erase down 进行复制、获取基址引用、销毁并可能移动（因为您正在内部存储）。

std::aligned_storage 用于您的任务（您可以传入您打算存储的所有类型的对齐要求）。然后就地新建对象。

通过void*构建一个table你想在对象上执行的操作——复制、移动、销毁和转换为base*.

template<class Sig>using f = Sig*;

struct table {
  f<base*(void*)>             convert_to_base;
  f<base const*(void const*)> convert_to_const_base;
  f<void(void*,void const*)>  copy_construct;
  f<void(void*)>              destroy;
  f<void(void*,void*)>        move_construct;
};
template<class T>
table const* get_table() {
  static table t = {
    // convert to base:
    [](void*p)->base*{
      T*t=static_cast<T*>(p);
      return t;
    },
    // convert to const base:
    [](void const*p)->base const*{
      T const*t=static_cast<T const*>(p);
      return t;
    },
    // etc
  };
  return &t;
}

现在将 get_table<T>() 存储在您的类型擦除实例中（它基本上是一个虚拟函数 table，手动实现），并编写您的包装正则 class 以使用来自table 操纵 aligned_storage<?...>.

现在，这可以通过使用 boost::variant 或通过像我的 some 类型那样更容易完成，它的行为类似于 any 而无需使用堆存储。 some link 包括编译上述伪虚函数 table 技术的实现。但是，我可能使用了错误的对齐存储，所以要小心。

Answer 2

您可以使用 std::aligned_storage 来包装您的类。假设Derived2最大：

class Storage
{
public:
  Storage(int data, int data2)
  {
    new (&data) Derived1(data, data2);
  }
  Storage(int data, float data2)
  {
    new (&data) Derived2(data, data2);
  }
  Base* getBase()
  {
    return reinterpret_cast<Base*>(&data);
  }
  ~Storage()
  {
    getBase()->Base::~Base();
  }
private:
  std::aligned_storage<sizeof(Derived2)> data;
};

C++ STL 容器中的多态性

Polymorphism in C++ STL containers

c++

polymorphism

stl

c++11