问题 连续存储多态类型

我试着在没有内存开销的情况下实现你想要的东西

template <typename Base, std::size_t MaxSize, std::size_t MaxAlignment>
struct PolymorphicStorage
{
public:
    template <typename D, typename ...Ts>
    D* emplace(Ts&&... args)
    {
        static_assert(std::is_base_of<Base, D>::value, "Type should inherit from Base");
        auto* d = new (&buffer) D(std::forward<Ts>(args)...);
        assert(&buffer == reinterpret_cast<void*>(static_cast<Base*>(d)));
        return d;
    }

    void destroy() { get().~Base(); }

    const Base& get() const { return *reinterpret_cast<const Base*>(&buffer); }
    Base& get() { return *reinterpret_cast<Base*>(&buffer); }

private:
    std::aligned_storage_t<MaxSize, MaxAlignment> buffer;
};

演示

但问题是复制/移动构造函数（和赋值）是不正确的，但我没有看到正确的方法来实现它没有内存开销（或对类的额外限制）。

我不能 =delete 他们，否则你不能使用它们 std::vector。

内存开销， variant 似乎更简单。

所以，这真的很难看，但是如果你没有使用多重继承或虚拟继承，那么 Derived * 在大多数实现中，将具有与a相同的位级值 Base *。

你可以测试一下 static_assert 因此，如果在特定平台上不是这种情况，则无法编译，并使用您的 union 理念。

#include <cstdint>

class Base {
 public:
   virtual bool my_virtual_func() {
      return true;
   }
};

class DerivedA : public Base {
};

class DerivedB : public Base {
};

namespace { // Anonymous namespace to hide all these pointless names.
constexpr DerivedA a;
constexpr const Base *bpa = &a;
constexpr DerivedB b;
constexpr const Base *bpb = &b;

constexpr bool test_my_hack()
{
   using ::std::uintptr_t;

   {
      const uintptr_t dpi = reinterpret_cast<uintptr_t>(&a);
      const uintptr_t bpi = reinterpret_cast<uintptr_t>(bpa);
      static_assert(dpi == bpi, "Base * and Derived * !=");
   }
   {
      const uintptr_t dpi = reinterpret_cast<uintptr_t>(&b);
      const uintptr_t bpi = reinterpret_cast<uintptr_t>(bpb);
      static_assert(dpi == bpi, "Base * and Derived * !=");
   }
   // etc...
   return true;
}
}

const bool will_the_hack_work = test_my_hack();

唯一的问题是constexpr规则将禁止您的对象拥有虚拟析构函数，因为这些将被视为“非平凡”。您必须通过调用必须在每个派生类中定义的虚函数来销毁它们，然后直接调用析构函数。

但是，如果这段代码成功编译，那么如果你得到一个就没关系 Base * 来自 DerivedA 要么 DerivedB 你工会的成员。无论如何，它们将是相同的。

另一种选择是在结构的开头嵌入一个指向充满成员函数指针的结构的指针，该结构包含该指针以及与其中派生类的并集，并自己初始化它。基本上，实现自己的vtable。

在CppCon 2017上有一个演讲，“运行时多态性 - 回归基础“，那讨论了做你喜欢的事情。 幻灯片 在github和谈话的视频是 在youtube上可用。

演讲者的 试验 实现这一目标的库，“dyno”，也是 在github上。

在我看来，你正在寻找一个 variant，这是一个安全访问的标记联盟。

c ++ 17有 std::variant。对于以前的版本，boost提供了一个版本 - boost::variant

请注意，不再需要多态性。在这种情况下，我使用了与签名兼容的方法来提供多态性，但您也可以通过兼容签名的自由函数和ADL来提供它。

#include <variant>   // use boost::variant if you don't have c++17
#include <vector>
#include <algorithm>

struct B {
  int common;
  int getCommon() const { return common; }
};

struct D1 : B {
  int getVirtual() const { return 5; }
};

struct D2 : B {
  int d2int;
  int getVirtual() const { return d2int; }
};

struct d_like
{
    using storage_type = std::variant<D1, D2>;

    int get() const {
        return std::visit([](auto&& b)
        {
            return b.getVirtual();
        }, store_);
    }

    int common() const { 
        return std::visit([](auto&& b)
        {
            return b.getCommon();
        }, store_);
    };

    storage_type store_;
};

bool operator <(const d_like& l, const d_like& r)
{
    return l.get() < r.get();
}

struct by_common
{
    bool operator ()(const d_like& l, const d_like& r) const
    {
        return l.common() < r.common();
    }
};

int main()
{
    std::vector<d_like> vec;
    std::sort(begin(vec), end(vec));
    std::sort(begin(vec), end(vec), by_common());
}