A polymorphic union in C++

Question

Sometimes I use std::unique_ptr<BaseClass> when all I really want is polymorphism. For fun, I made this container that skips the heap allocation. The downside is that it needs to know all possible derived types it will store in order to know how much space to reserve.

Any feedback is appreciated, but I'm especially interested in how this implementation enables/prevents compiler optimizations you would otherwise have with virtual types.

Edit: I am also intersted in supporting constexpr access, but right now the reinterpret_cast prevents constexpr dereference.

#include <algorithm>
#include <type_traits>

template <typename B, size_t Size, size_t Align>
struct PolyUnionSize {
    template <typename D>
    explicit PolyUnionSize(D&& d) noexcept (std::is_nothrow_copy_constructible_v<D>) {
        new(&storage) D(std::forward<D>(d));
    }

    template <typename D>
    PolyUnionSize& operator=(D&& d) noexcept(std::is_nothrow_assignable_v<B, D>) {
        this->~PolyUnionSize();
        *(new(&storage) D) = std::forward<D>(d);
        return *this;
    }

    ~PolyUnionSize() noexcept {
        (*this)->~B();
    }

    B const& operator*() const noexcept {
        return *reinterpret_cast<B const*>(&storage);
    }

    B& operator*() noexcept {
        return *reinterpret_cast<B*>(&storage);
    }

    B const* operator->() const noexcept {
        return reinterpret_cast<B const*>(&storage);
    }

    B* operator->() noexcept {
        return reinterpret_cast<B*>(&storage);
    }

private:
    typename std::aligned_storage<Size, Align>::type storage;
};

constexpr auto max(std::initializer_list<std::size_t> const& t) noexcept {
    return *std::max_element(std::begin(t), std::end(t));
}

template <typename B, typename ... Ds>
struct PolyUnion : public PolyUnionSize<B, max({sizeof(Ds)... }), max({alignof(Ds)... })> {
    using PUSize = PolyUnionSize<B, max({sizeof(Ds)... }), max({alignof(Ds)... })>;

    template <typename D>
    explicit PolyUnion(D&& d) noexcept(std::is_nothrow_copy_constructible_v<D>)
        : PUSize(std::forward<D>(d))
    {
        static_assert((std::is_base_of_v<B, Ds> && ...));
        AssertDinDs<D>();
    }

    template <typename D>
    PolyUnion& operator=(D&& d) noexcept(std::is_nothrow_assignable_v<B, D>) {
        AssertDinDs<D>();
        PUSize::operator=(std::forward<D>(d));
        return *this;
    }

private:
    template <typename D>
    constexpr void AssertDinDs() const& noexcept{
        static_assert((std::is_same_v<D, Ds> || ...));
    }
};

Sample usage:

struct Base {
    virtual int Foo() const { return 1; }
};

struct A : Base {
    int Foo() const final { return 2; }
};

struct B : Base {
    int Foo() const final { return 3; }
};

int main() {
    PolyUnion<Base, A, B> pu(A{});
    pu = B{};
    return pu->Foo();
}

Compiles with -std=c++17 or -std=c++2a

Answer 1

1. I suggest not codifying the derived types suggested in the type. Only note the ultimate base, size and alignment. Thus you are open to later change.

   Add a templated alias to get the proper type from base plus candidates.

2. Assure that no over-sized object is ever assigned in PolyUnionSize, probably best using SFINAE. No need to defer to the user.

3. Don't assume constructing the new object will never fail.

4. PolyUnionSize::PolyUnionSize<class D>(D&& d) and PolyUnionSize::operator=<class D>(D&& d) use perfect forwarding. You don't account for that by using std::decay_t where needed, nor heed it when computing noexcept.

5. The implicit copy-/move- ctor / assignment are only appropriate for trivial types. And in that case, why override the dtor?

6. As casts should be used sparingly, consider delegating between op* and op->.

Answer 2

We're in C++17, so we can use std::aligned_storage_t:

typename std::aligned_storage_t<Size, Align> storage = {};

(I added the initializer to pacify g++ -Weffc++; I also added virtual ~Base() = default; for the same reason).

One thing that breaks is that I can't assign a B to the object unless the base is explicitly listed as one of the Ds.... Perhaps that's intentional; it's certainly worth noting in the documentation if it is (I note that the posted code has no documentary comments - that really should be fixed).

I get a long cascade of errors if I instantiate with only the base type and empty Ds...:

PolyUnion<Base> foo(Base{});

We can reduce that greatly by constraining with concepts, or just make this degenerate case be valid, by including the base type in the max() call:

template <typename B, typename ... Ds>
struct PolyUnion
    : public PolyUnionSize<B,
                           max({sizeof(B), sizeof(Ds)... }),
                           max({alignof(B), alignof(Ds)... })>
{
    using PUSize = PolyUnionSize<B,
                                 max({sizeof(B), sizeof(Ds)... }),
                                 max({alignof(B), alignof(Ds)... })>;

I tried adding a static_assert() to force non-empty Ds..., but that didn't reduce the log spam very much, and I was unable to use std::enable_if to SFNIAE the template out for empty Ds. I did get a useful, short error message by specializing the template for that case, though:

template <typename B>
class PolyUnion<B>;     // deliberately incomplete