I have an array of a struct, lets say

struct cell{
  int pos;
  int id;
};

std::vector<cell> myArray;

I want an array of the id element. I can't just iterate over my array as it would take too long.

I have to provide std::vector<int> to a function.

My thought process was: Since arrays are usually just a pointer to the first element and then an offset I thought of creating an array where i can provide the offset, such as it would point to the id element of the next cell in std::vector<cell> myArray.

One solution I can think of is having an array of pointers to that element, for example:

The final solution might be something like:

struct cell{
  int pos;
  int id;
};

std::vector<cell> myArray;
std::vector<int*> pointersToIds;

// Creating an array of int from an array of int*
std::vector<int> idsArray = std::something(pointersToIds);

myFunc(idsArray);

Since the std library has tons of stuff I supposed there would be a way to do this.

Is there a way to convert the array of pointers to an actual array of elements in a very optimized way? The pointers approach was the only i could think but it's doesn't necessarily have to be it.

Thank you all in advance :)

I tried iterating over the the array of pointers and creating an array of elements, but it would take too much time.

TLDR Get array of an element from array of struct

CodePudding user response：

I suppose this might be an instance of The XY Problem, since it's not clear what you are actually trying to solve, do you:

1. Want to find a fast way to pass the list of struct to a function
2. Want a way to extract all the members from a list of struct into a list of members

First off, shoo away from your mind the idea of manually creating an array of addresses and then fiddling around with the offsets yourself, this is certainly doable, but probably hard to do yourself in a safe and portable way due to Struct Alignment, something that differs from machine to machine.

besides accessing cell.id is already doing that in a portable way by itself!

Problem 1.

If you want to pass a vector (or any object really) to a function in a fast way, you can use a reference, it would look something like this:

void foo(std::vector<cell>& in_vec);

notice the & operator, declaring that in_vec must be passed as a reference, what this does internally is pass in_vec by address, avoiding copying values one by one, C does all this by himself and you can treat in_vec normally in the function without a care in the world, and it's blazing fast.

Problem 2.

if your point is that you want to extract all the IDs before passing them to a function, first off, I still suggest you pass the cell, that way it is clear that foo is supposed to operate on cell IDs and not random integers, once again, paying the cost of unpacking the structs outside (which warrants an iteration) or inside (where you might not even need to access all cells depending on foo's nature) is equal if not worse.

If you must carry through, it's as easy as a for loop:

std::vector<int> ids;

for(auto const& cell : myArray)
{
    ids.push_back(cell.id); 
}

Or, if you want a elegant and modern solution, using lambdas and algorithm:

#include <algorithm>

std::vector<int> ids;

std::transform(myArray.begin(), myArray.end(), 
std::back_inserter(ids), [](cell const& c) {
    return c.id;
});

Or something to this effect.