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类.

现在我想将它们存储在一个std::vector,如果我想使用多态,我被迫存储指针,否则对象切片将阻止我存储其他派生属性.所以我基本上被迫使用了std::vector<unique_ptr<Base>>.

但是我们假设我需要存储大量这些对象,我不想浪费双堆分配(内部std::vector+对象本身),同时我可以假设:

• 类层次结构是完美定义的,如果不知道就不会扩展
• 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并将地址std::vector转换为所需类型的元素(根据枚举),则不应发生对象切片,但这听起来也很丑陋.

Answer 1

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

您可以在 C++ 中键入擦除几乎任何属性，从而创建一个“知道”如何将属性应用于现在未知的类型的自定义接口。

boost::anytype 擦除以复制、销毁、获取 typeid 并转换回完全匹配的类型。 std::function类型擦除以复制、使用特定签名调用、销毁和转换回相同类型（最后一个很少使用）。

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

在您的情况下，您需要在该类型中创建一个“足够大”的对齐存储。您需要输入“erase down”来复制、获取基址引用、销毁并可能移动（正如您在内部存储的那样）。

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

void*通过复制、移动、销毁和转换为来构建您想要对对象执行的操作表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操作aligned_storage<?...>.

boost::variant现在，可以通过使用或通过类似我的某种类型（其行为类似于 aany而不使用堆存储）来更轻松地完成此操作。某些链接包括编译上述伪虚拟函数表技术的实现。不过，我可能错误地使用了对齐存储，所以要小心。