inserting a range of struct vector into a vector of a struct member type

Question

Is it possible to insert range of struct directly into vector of the same type (same type of a member of struct).

Let's have a struct and vectors like this:

struct pnt {
  char _name;
  int _type;
  bool _aux;
  };

std::vector<pnt> pnts;
std::vector<int> pntType;

The question is that how to insert a range of pnts into pntType using single standard line of C++98:

void insert (iterator position, InputIterator first, InputIterator last);

or even Boost library. Since I am using this often in different parts of my code, I am trying to avoid doing this in a loop. The last option is defining a function for that.

EDIT:

I know the insert syntax. What I cannot do is how to insert from pnts (only _type of each member) into pntType

Answer 1

Using boost range:

boost::copy(pnts | transformed(std::mem_fn(&pnt::_type)), std::back_inserter(pntType));

Or even

boost::copy_range<std::vector<int>>(pnts | transformed(std::mem_fn(&pnt::_type)));

See it Live on Coliru

Note you can use boost::bind(&pnt:_type,_1) instead of mem_fn to allow for your compiler version

Updated To show with specific first/last iterators, and compiling in c++03 mode:

Live On Coliru

#include <boost/range/algorithm.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/bind.hpp>

using namespace boost::adaptors;
using namespace boost;

struct pnt {
    char _name;
    int _type;
    bool _aux;
};

int main() {

    std::vector<pnt> pnts(6);
    std::vector<int> pntType;

    boost::copy(
            make_iterator_range(pnts.begin(), pnts.begin()+3) | transformed(bind(&pnt::_type, _1)), 
            std::back_inserter(pntType));
}

Answer 2

Inserting one container into the other works like this:

pntType.insert(pntType.begin(),pnts.begin(),pnts.end());

To be able to insert the correct type, you should add a conversion operator to int to your struct.

struct pnt {
  char _name;
  int _type;
  bool _aux;

  operator int (){
    return _type;
  }     
};

Answer 3

UPDATE: There is a better way than my first suggestion (see bottom), since we're already using Boost. The problem with std::transform and std::insert_iterator is that v2 is resized several times, which is wasteful considering that we know the width of the range in advance. Using boost::transform_iterator and boost::bind, it is possible to avoid the problem like this:

#include <boost/bind.hpp>
#include <boost/iterator/transform_iterator.hpp>

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

struct A {
  int x;
};

int main() {
  A arr[] = {
    { 0 }, { 1 }, { 2 }, { 3 }, { 4 }, { 5 }, { 6 }
  };

  std::vector<A> v1(arr, arr + 6);
  std::vector<int> v2;

  v2.insert(v2.begin(),
            boost::make_transform_iterator(v1.begin() + 2, boost::bind(&A::x, _1)),
            boost::make_transform_iterator(v1.begin() + 4, boost::bind(&A::x, _1)));

  std::copy(v2.begin(), v2.end(), std::ostream_iterator<int>(std::cout, "\n"));
}

OLD SUGGESTION:

boost::bind works with data member pointers, so using C++98 and Boost, you could do something like this without changing your struct:

#include <boost/bind.hpp>

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

struct A {
  int x;
};

int main() {
  A arr[] = {
    { 0 }, { 1 }, { 2 }, { 3 }, { 4 }, { 5 }, { 6 }
  };

  std::vector<A> v1(arr, arr + 6);
  std::vector<int> v2;

  // one-liner here:
  std::transform(v1.begin() + 2,
                 v1.begin() + 4,
                 std::insert_iterator<std::vector<int> >(v2, v2.begin()),
                 boost::bind(&A::x, _1));

  std::copy(v2.begin(), v2.end(), std::ostream_iterator<int>(std::cout, "\n"));
}