Great question! This is a common need in performance-critical code where you want to switch between AoS (cache-friendly for random access) and SoA (cache-friendly for bulk operations) without rewriting your core logic. Let's break this down:

Are there existing implementations? #

Yes, several production-grade libraries offer this exact functionality with zero-cost abstractions:

• Folly's SoaContainer: Facebook's Folly library includes a SoaContainer template that automatically splits a struct into its constituent members for SoA storage. It provides a compatible interface with standard containers, so you can use range-based for loops and familiar access patterns just like with a regular std::vector.
• EASTL's soa_vector: The Electronic Arts Standard Template Library (EASTL) has a soa_vector optimized for performance-critical applications (like games). It handles SoA/AoS-like access with minimal overhead and supports custom structs out of the box.
• Boost.PFR: While not a container itself, Boost's Plain Old Data Reflection (PFR) library lets you automatically introspect struct members at compile time. You can use this to build a custom SoA container without manually writing boilerplate for each struct's members.

Best approach for a custom implementation #

If you need a tailored solution (instead of relying on external libraries), here's a step-by-step zero-cost abstraction design:

1. Define layout tags

Start with empty tag types to select the memory layout at compile time:

struct AoS {};
struct SoA {};

2. Implement the AoS container (trivial wrapper)

For AoS, we just wrap a standard std::vector—this has zero overhead since it's a direct alias for the underlying container:

template<typename T>
class MyContainer<T, AoS> {
private:
    std::vector<T> data_;
public:
    using value_type = T;
    using reference = T&;
    using const_reference = const T&;
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

    MyContainer(size_t size) : data_(size) {}

    iterator begin() { return data_.begin(); }
    iterator end() { return data_.end(); }
    const_iterator begin() const { return data_.begin(); }
    const_iterator end() const { return data_.end(); }

    reference operator[](size_t idx) { return data_[idx]; }
    const_reference operator[](size_t idx) const { return data_[idx]; }

    size_t size() const { return data_.size(); }
    void reserve(size_t n) { data_.reserve(n); }
};

3. Implement the SoA container with proxy objects

For SoA, we split the struct's members into separate vectors, then use a proxy class to mimic the original struct's interface. This ensures your loop code stays identical:

First, create a traits class to map your struct's members to their types and accessors (skip this if using Boost.PFR for auto-reflection):

template<typename T>
struct MemberTraits;

template<>
struct MemberTraits<Item> {
    using DoubleType = double;
    using CharType = char;
    using StringType = std::string;

    static DoubleType& getDouble(Item& item) { return item.myDouble(); }
    static const DoubleType& getDouble(const Item& item) { return item.myDouble(); }

    static CharType& getChar(Item& item) { return item.myChar(); }
    static const CharType& getChar(const Item& item) { return item.myChar(); }

    static StringType& getString(Item& item) { return item.myString(); }
    static const StringType& getString(const Item& item) { return item.myString(); }
};

Then implement the SoA container with proxies and custom iterators:

template<typename T>
class MyContainer<T, SoA> {
private:
    using Traits = MemberTraits<T>;
    std::vector<typename Traits::DoubleType> doubles_;
    std::vector<typename Traits::CharType> chars_;
    std::vector<typename Traits::StringType> strings_;

    // Proxy class mimics the Item interface
    class Proxy {
    private:
        MyContainer& container_;
        size_t idx_;
    public:
        Proxy(MyContainer& container, size_t idx) : container_(container), idx_(idx) {}

        auto& myDouble() { return container_.doubles_[idx_]; }
        const auto& myDouble() const { return container_.doubles_[idx_]; }

        auto& myChar() { return container_.chars_[idx_]; }
        const auto& myChar() const { return container_.chars_[idx_]; }

        auto& myString() { return container_.strings_[idx_]; }
        const auto& myString() const { return container_.strings_[idx_]; }
    };

    // Const-safe proxy
    class ConstProxy {
    private:
        const MyContainer& container_;
        size_t idx_;
    public:
        ConstProxy(const MyContainer& container, size_t idx) : container_(container), idx_(idx) {}

        const auto& myDouble() const { return container_.doubles_[idx_]; }
        const auto& myChar() const { return container_.chars_[idx_]; }
        const auto& myString() const { return container_.strings_[idx_]; }
    };

    // Random-access iterator for range-based for loops
    template<bool IsConst>
    class Iterator {
    private:
        using Container = std::conditional_t<IsConst, const MyContainer, MyContainer>;
        Container* container_;
        size_t idx_;
    public:
        using value_type = std::conditional_t<IsConst, ConstProxy, Proxy>;
        using reference = value_type;
        using difference_type = ptrdiff_t;
        using iterator_category = std::random_access_iterator_tag;

        Iterator(Container* container, size_t idx) : container_(container), idx_(idx) {}

        value_type operator*() { return value_type(*container_, idx_); }
        Iterator& operator++() { ++idx_; return *this; }
        Iterator operator++(int) { auto tmp = *this; ++idx_; return tmp; }
        Iterator& operator--() { --idx_; return *this; }
        Iterator operator--(int) { auto tmp = *this; --idx_; return tmp; }
        bool operator==(const Iterator& other) const { return container_ == other.container_ && idx_ == other.idx_; }
        bool operator!=(const Iterator& other) const { return !(*this == other); }
    };

public:
    using reference = Proxy;
    using const_reference = ConstProxy;
    using iterator = Iterator<false>;
    using const_iterator = Iterator<true>;

    MyContainer(size_t size) : doubles_(size), chars_(size), strings_(size) {}

    iterator begin() { return iterator(this, 0); }
    iterator end() { return iterator(this, size()); }
    const_iterator begin() const { return const_iterator(this, 0); }
    const_iterator end() const { return const_iterator(this, size()); }

    reference operator[](size_t idx) { return Proxy(*this, idx); }
    const_reference operator[](size_t idx) const { return ConstProxy(*this, idx); }

    size_t size() const { return doubles_.size(); }
    void reserve(size_t n) {
        doubles_.reserve(n);
        chars_.reserve(n);
        strings_.reserve(n);
    }
};

4. Use the container interchangeably

Now you can switch layouts without changing your loop code:

// AoS layout
MyContainer<Item, AoS> aos_vec(1000);
for (auto& i : aos_vec) {
    i.myDouble() = 5.0;
}

// SoA layout
MyContainer<Item, SoA> soa_vec(1000);
for (auto& i : soa_vec) {
    i.myDouble() = 5.0;
}

Key notes for zero overhead #

• All logic is resolved at compile time via template specialization—no runtime checks or indirection.
• The proxy class is a lightweight wrapper (just a container reference and index), so it's as efficient as accessing the vectors directly.
• Iterators follow standard C++ iterator rules, so they work with all standard algorithms.

内容的提问来源于stack exchange，提问作者Paolo Crosetto