Can I iterate over class members as though they were an array in C++?

Question

Suppose I have a class akin to the following:

struct Potato {
    Eigen::Vector3d position;
    double weight, size;
    string name;
};

and a collection of Potatos

std::vector<Potato> potato_farm = {potato1, potato2, ...};

This is pretty clearly an array-of-structures (AoS) layout because, let's say for most purposes, it makes sense to have all of a Potato's data lumped together. However, I might like to do a calculation of the most common name where a structure-of-arrays (SoA) design makes things agnostic to the type of thing with a name (an array of people all with names, an array of places, all with names, etc.) Does C++ have any tools or tricks that makes an AoS layout look like a SoA to do something like this, or is there a better design that accomplishes the same thing?

how would it make it any easier? or how is calculating the mean not easy now? Just iterate over your `potato_farm`, access the weight, calc the mean, done. Of course if you mean more memory efficient then it might have a advantage to have a structure of arrays, but I dont get the point of different "looks" because there is little difference in the code to get eg the mean weight — 463035818_is_not_an_ai, Jun 27 '17 at 15:40
@tobi303 It's much more natural to interface with STL algorithms with a structure of arrays (each of the arrays would have `begin` and `end` methods that can feed an e.g. `std::accumulate` natively without having to write a whole bunch of lambda functions to dig out the relevant member variables). — rayhem, Jun 27 '17 at 15:44
@ConnorGlosser You only have to write a single lambda for `std::accumulate` though, not a lot. It's not "easier" with your structures of arrays IMO. — Rakete1111, Jun 27 '17 at 15:46
@ConnorGlosser yeah I was thinking about it, you would have to write some boilerplate to make `std::accumulate` access the members — 463035818_is_not_an_ai, Jun 27 '17 at 15:46
Your `potato_farm` could provide an `begin` and `end` iterator for each member. That iterator simply wraps the vector iterator but returns the appropriate member when dereferenced. Then you would save the lambdas — 463035818_is_not_an_ai, Jun 27 '17 at 15:48
@Rakete1111 A better example might be some code that processes a collection of `name`s, be they for potatoes, people, places, etc. In that case it'd be really easy to pull out the `std::vector` from any SoA. — rayhem, Jun 27 '17 at 15:56

score 4 · Answer 1 · answered Jun 27 '17 at 15:49

You can use lambdas to access particular member in algos that work over range:

double mean = std::accumulate( potato_farm.begin(), potato_farm.end(), 0.0, []( double val, const Potato &p ) { return val + p.weight; } ) / potato_farm.size();

if that is not enough you cannot make it look like array of data as that requires objects to be in continuous memory, but you can make it like a container. So you can implement custom iterators (for example random access iterator of type == double which iterates over weight member). How to implement custom iterators is described here. You can probably even make that generic, but it is not clear if that would worse the effort as it is not very simple to implement properly.

score 1 · Accepted Answer · answered Jun 27 '17 at 16:00

Unfortunately, there is no language tool to generically change a struct into SoA. This is actually one of big obstacles when you try to bring SIMD programming into higher level.

You will need to create a SoA manually. However, you can help yourself by creating a reference to SoA objects acting as if it was a regular Potato.

struct Potato {
    float position;
    double weight, size;
    std::string name;
};
struct PotatoSoARef {
    float& position;
    double& weight;
    double& size;
    std::string& name;
};
class PotatoSoA {
private:
    float* position;
    double* weight;
    double* size;
    std::string* name;
public:
    PotatoSoA(std::size_t size) { /* allocate the SoA */ }
    PotatoSoARef operator[](std::size_t idx) {
        return PotatoSoARef{position[idx], weight[idx], size[idx], name[idx]};
    }
};

This way, regardless if you have an AoS or SoA of Potatos, you can access its fields as arr[idx].position etc. (both as r- and l-value). The compiler is likely to optimize the proxy away.

You might want to add other constructors and accessors as well.

You might also be interested in implementing a regular AoS with an operator[] returning a PotatoSoARef if you want functions to have a uniform interface for both AoS and SoA access patterns.

If you are willing to depart from C++ though, you might be interested in language extensions such as Sierra

score 0 · Answer 3 · answered Jun 27 '17 at 15:56

As Slava has said you aren't going to get SoA-like access out of AoS data without writing your own iterators, and I would think really hard about whether the use of STL algorithms is that important before doing that, especially if this isn't meant to be a generic solution. The primary benefit of SoA data is cache performance anyway, not the particular syntax of whatever containers you're using, and nothing besides actual SoA data is going to get you that.

score 0 · Answer 4 · answered Jun 27 '17 at 16:22

With range-v3 (not in C++17 :-/ ), you may use Projection or transformation view:

ranges::accumulate(potato_farm, 0., ranges::v3::plus{}, &Potato::weight);

or

auto weightsView = potato_farm | ranges::view::transform([](auto& p) { return p.weight; });
ranges::accumulate(weightsView, 0.);

Can I iterate over class members as though they were an array in C++?

4 Answers4