C++STL容器中的多态性

Polymorphism in C++ STL containers

本文关键字：多态性 C++STL      更新时间：2023-10-16

我想知道这个问题是否有一个优雅的解决方案。

假设如下：

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中元素的地址强制转换为所需类型（根据枚举），但这听起来也很难看。

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

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

boost::any类型向下擦除以复制、销毁、获取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，或者通过类似于我的some类型的不使用堆存储的any，可以更容易地实现这一点。一些链接包括上面的伪虚拟函数表技术的编译实现。不过，我可能使用了错误的对齐存储，所以要小心。

您可以使用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;
};
相关文章：