Can I move elements out of range?

Question

Suppose I have code like this:

std::vector<std::string> produce(const std::string& str){
    // create a vector based on input
}

void consume(const std::string& str){
    for (auto i:produce(str))
        // do some thing that use the str
        // and I'd like to move it from the vector
        some_process(str) // for example, move into this function
}

I'm just wondering if the compiler (I can use VS2015 or gcc 6) can optimize to move elements in a for-loop. Or what I need to do to make it move, as the line can be quite long.

Will the old start end for a coroutine loop or coroutine?

Answer 1

If you want to move elements from this vector to some_function(), just do it moveexplicitly:

void some_function( std::string str );
void some_function( std::string &&str ); // or explicitly


for(auto &i:produce(str))
    some_function( std::move(i) );

Otherwise, it is unclear what you mean by moving elements into a loop.

Answer 2

auto& std::move .

struct empty_t{}; 
template<class It,class B=empty_t>struct range_t:B{
  It b,e;
  It begin()const{return b;}
  It end()const{return e;}
  range_t(It s,It f):b(std::move(s)),e(std::move(f)){}
  // fancy
  template<class S, class F>
  range_t(B base, S s, F f):B(std::move(base)),b(s(*this)),e(f(*this)){}
};
template<class It>range_t<It> range(It b, It e){return{std::move(b),std::move(e)};}
template<class B, class S, class F>
auto range( B base, S s, F f ){
  auto It=std::result_of_t<s(base)>;
  return range_t<It,B>{
    std::move(base),std::move(s),std::move(f)
  };
}
template<class R>
auto move_from(R& r){
  using std::begin; using std::end;
  return range( std::make_move_iterator(begin(r)), std::make_move_iterator(end(r)) ); 
}
template<class R>
auto move_from(R&& r){
  using std::begin; using std::end;
  return range(
    std::move(r),
    [](auto&r){return std::make_move_iterator(begin(r));},
    [](auto&r){return std::make_move_iterator(end(r));}
  ); 
}

, ,

for(auto i:move_from(produce(str)))
  some_function( std::move(i) );

i .

.

, /, .

template<class R, class F>
auto transform_to_vector( R&& r, F&& f ){
  using std::begin; using std::end;
  using rT=std::decay_t<std::result_of_t< f(*begin(std::forward<R>(r))) >>;
  std::vector<rT> retval;
  for(auto&& e:std::forward<R>(r)){
    retval.push_back( f(decltype(e)(e)) );
  }
  return retval;
}

, move_from(x), "" x. , .