CODEWITHSUNDEEP
c++arrays
rayhem
rayhem

Reputation: 771

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

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?

Upvotes: 2

Views: 279

Answers (4)

Jarod42
Jarod42

Reputation: 217245

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.);

Upvotes: 0

CygnusX1
CygnusX1

Reputation: 21779

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

Upvotes: 1

nzerbzer
nzerbzer

Reputation: 115

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.

Upvotes: 0

Slava
Slava

Reputation: 44248

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.

Upvotes: 4

Related Questions