Building a vector from components contained in another vector type

Question

I have a code that looks something like this:

struct First
{
    int f1;
    int f2;
};

struct Second
{
    First s1;
    int s2;
};

std::vector < Second > secondVec;

Second sec;
sec.s1 = First(); 

secondVec.push_back(sec);
secondVec.push_back(sec);

std::vector < First > firstVec;
firstVec.reserve(secondVec.size());

for (std::vector < Second >::iterator secIter = secondVec.begin(); 
         secIter != = secondVec.end();
         ++secIter)
{
    firstVec.push_back(secIter->s1);
}

I'd like to replace this ugly for loop with a simple stl function that could perhaps perform the equivalent process. I was thinking that maybe std::transform could help me here, but I'm unsure as to how this could be written.

I'd also be interested if boost has anything to offer here.

Answer 1

Its not particularly difficult ... I tried this and it worked no problems.

struct First
{
    int f1;
    int f2;
};

struct Second
{
    First s1;
    int s2;
};

First Replace( Second& sec )
{
    return sec.s1;
}

and then used the following code to copy it

std::vector < Second > secondVec;

Second sec;
sec.s1.f1 = 0; 
sec.s1.f2 = 1; 
secondVec.push_back(sec);

sec.s1.f1 = 2; 
sec.s1.f2 = 3; 
secondVec.push_back(sec);

std::vector < First > firstVec;
firstVec.resize( secondVec.size() );
std::transform( secondVec.begin(), secondVec.end(), firstVec.begin(), Replace );

Answer 2

You were right with your intuition. Although since you are using an empty vector, you should use a back inserter for your output iterator.

It should look like something of the like :

std::transform(secondVec.being(), secondVec.end(), back_inserter(firstVec), yourFunctor)

And yourFunctor looking like this :

void youFunctor(First param)
{
  return param.s1;
}

Edit : Boost could help you with lambda function so you wouldn't have to create a separate functor for this task. You should also note that lambda function function are part of the TR1 and will be integrated to the C++ standard library.

Edit : Here is what Meredith was talking about with mem_fun (or member function adaptor).

 struct Second
{
    First s1;
    int s2;
    First getS1() const {return s1;};
};

And then the transform would look like this :

std::transform(secondVec.being(), 
               secondVec.end(), 
               std::back_inserter(firstVec), 
               std::mem_fun(&Second::getS1))

Answer 3

Define functor that will transform Second to First:

struct StoF { First operator()( const Second& s ) const { return s.s1; } };

Then use it in the following way:

transform( secondVec.begin(), secondVec.end(), back_inserter(firstVec), StoF() );

If your source vector contains a lot of elements you should consider resizing destination vector to make it work faster, as in @Goz answer:

firstVec.resize( secondVec.size() );
transform( secondVec.begin(), secondVec.end(), firstVec.begin(), StoF() );

Answer 4

If you have TR1 or Boost available, you could try this:

std::transform(secondVec.begin(),
               secondVec.end(),
               std::back_inserter(firstVec),
               std::tr1::bind(&Second::s1, _1));