Calculate the size of the non-standard-layout structure with open array

The whole concept has undefined behavior in C++.

There is generally no valid way to get from a pointer to a MultipleValuesEntry beyond it's fixed compile-time size. There are specific exceptions, e.g. when MultipleValuesEntry itself is first member of a standard-layout class object that also contains all the entries after it, but they don't help you for an actually dynamic number of entries.

In C this is allowed as so-called "flexible array member", but such a member must be declared as an array with unknown size, i.e. without a specified size in the brackets.

In C++ there is no equivalent to this. Some compilers support flexible array members as a language extension, but if they do there will be a lot of limitations in how the feature interacts with other C++ features, in particular inheritance. In any case, the standard does not consider this extension and therefore you won't find it defining any of your attempts to use this pattern.

It can be done in C++, without UB. But you will have to manage the Make and Destroy of the backing store buffer of the "open array" object yourself. This is not idiomatic C++ code, and I strongly advise against doing something like this. Instead use std::vector.

Unless you've profiled the performance and have found that cache friendly locality has a measurable improvement that warrants using something like this approach.

Real code should also prohibit copy-ctor, move-ctor, copy-assignment, move-assignment. They won't work right.

Compiler explorer link.

#include <algorithm>
#include <cstddef>
#include <iostream>
#include<cassert>

using std::size_t;

namespace {
enum class EntryType {
    SingleElement,
    MultipleElements
};

struct Entry {
    Entry* next_{};
    EntryType type_{EntryType::SingleElement};
    virtual ~Entry() = default;
    virtual void print() = 0;
};

struct SingleValueEntry : Entry {
    SingleValueEntry(int value_) : value{value_} {}
    int value;
    void print() override { std::cout << value << "\n"; }
};

struct MultipleValuesEntry : Entry {
    MultipleValuesEntry(size_t size_, int value_) : size{size_} {
        for (auto p{ begin() }, e{ end() }; p != e; ++p) {
            // Placement new each int.  Not placement array new[].
            new (p)int{value_};
        }
    }

    ~MultipleValuesEntry() override {
        for (auto p{ begin() }, e{ end() }; p != e; ++p) {
            // Placement delete each int.  Not placement array delete[].
            // p->~int(); // Hmmm, does `int` have a placement destructor syntax?  Just let it drop on the floor, since its destructor is super-trivial no-op?
        }
    }

    size_t size;
    int dummy_[1]; // Not used.  Kind of needed for appropriate alignment padding, which could be done with a static_assert instead.

    void set_values(int value_) {
        std::fill(begin(), end(), value_);
    }

    auto operator[](size_t i) -> int& {
        assert(i < size);
        return begin()[i];
    }

    auto begin() -> int* {
        void* addr{ this };
        auto ptr{ static_cast<std::byte*>(addr) };
        ptr += sizeof(*this);
        return reinterpret_cast<int*>(ptr);
    }

    auto end() -> int* {
        auto ptr{ begin() + size };
        return ptr;
    }

    static auto Make(size_t value_array_size_, int value_) -> MultipleValuesEntry* {
        assert(value_array_size_ > 1);
        auto byte_size{ estimate_size(value_array_size_) };
        auto ptr = new std::byte[byte_size];
        auto result = new (ptr)MultipleValuesEntry{value_array_size_, value_};
        return result;
    }

    static void Destroy(MultipleValuesEntry* ptr) {
        ptr->~MultipleValuesEntry();
        auto byte_ptr{ reinterpret_cast<std::byte*>(ptr) };
        delete[] byte_ptr;
    }

    void print() override {
        for (auto p{ begin() }, e{ end() }; p != e; ++p) {
            std::cout << *p << " ";
        }

        std::cout << "\n";
    }

private:
    static constexpr auto estimate_size(size_t value_array_size_) noexcept -> size_t {
        assert(value_array_size_ > 1);
        auto size{ sizeof(MultipleValuesEntry) + sizeof(int) * value_array_size_ };
        return size;
    }
};

void print(Entry* p) {
    while (p) {
        p->print();
        p = p->next_;
    }
}
} // anon

int main() {
    auto sve{ new SingleValueEntry{100} };
    auto mve{ MultipleValuesEntry::Make(9, 81) };
    auto sve2{ new SingleValueEntry{200} };

    // Connect the entries.
    sve->next_ = mve;
    mve->next_ = sve2;

    // Print them!
    std::cout << "Original...\n";
    print(sve);

    // Tweak values.
    mve->set_values(86);
    (*mve)[4] = 444;

    // Print them!
    std::cout << "\nAfter tweaking...\n";
    print(sve);

    // Show is over.  Elvis has left the building.  Everyone go home.
    delete sve;
    MultipleValuesEntry::Destroy(mve);
    delete sve2;
}