RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/reference/iterator/move_iterator/ below:

class template

std::move_iterator

template <class Iterator> class move_iterator;

Move iterator

This class adapts an iterator so that dereferencing it produces rvalue references (as if std::move was applied), while all other operations behave as in the regular iterator.

This iterator adaptor keeps an internal copy of an iterator (known as its base iterator) on which all operations are reflected. A copy of the base iterator with the current state can be obtained at any time by calling member base.

Template parameters

Iterator: An input iterator type.
The use of certain of its members may require the iterator category to be bidirectional or random-access.

Member types member definition in move_iterator description iterator_type Iterator Iterator's type iterator_category iterator_traits<Iterator>::iterator_category Preserves Iterator's category value_type iterator_traits<Iterator>::value_type Preserves Iterator's value type difference_type iterator_traits<Iterator>::difference_type Preserves Iterator's difference type pointer Iterator (same as iterator_type) reference value_type&&
Member functions

(constructor): Construct move_iterator object (public member function)

base: Return base iterator (public member function)

operator*: Dereference iterator (public member function)

operator+: Addition operator (public member function)

operator++: Increment iterator position (public member function)

operator+=: Advance iterator (public member function)

operator-: Subtraction operator (public member function)

operator--: Decrease iterator position (public member function)

operator-=: Decrease iterator (public member function)

operator->: Dereference iterator (public member function)

operator[]: Dereference iterator with offset (public member function)

Non-member function overloads

relational operators: Relational operators for move_iterator (function template)

operator+: Addition operator (function template)

operator-: Subtraction operator (function template)

Non-member helper functions

make_move_iterator: Construct move iterator (function template)

Example

// move_iterator example
#include <iostream>     // std::cout
#include <iterator>     // std::move_iterator
#include <vector>       // std::vector
#include <string>       // std::string
#include <algorithm>    // std::copy

int main () {
  std::vector<std::string> foo (3);
  std::vector<std::string> bar {"one","two","three"};

  typedef std::vector<std::string>::iterator Iter;

  std::copy ( std::move_iterator<Iter>(bar.begin()),
              std::move_iterator<Iter>(bar.end()),
              foo.begin() );

  // bar now contains unspecified values; clear it:
  bar.clear();

  std::cout << "foo:";
  for (std::string& x : foo) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

Output:

Possible implementation

namespace std {
template <class Iterator> class move_iterator {
  Iterator current;
public:
  typedef Iterator iterator_type;
  typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
  typedef typename iterator_traits<Iterator>::value_type        value_type;
  typedef typename iterator_traits<Iterator>::difference_type   difference_type;
  typedef Iterator pointer
  typedef value_type&& reference;

  move_iterator() {}
  explicit move_iterator (Iterator it) : current(it) {}
  template <class Iter> move_iterator (const move_iterator<Iter>& it) : current(it.current) {}
  template <class Iter> move_iterator& operator= (const move_iterator<Iter>& it)
  { current = it.current; }

  iterator_type base() const { return current; }
  pointer operator->() const { return current; }
  reference operator*() const { return std::move(*current); }
  move_iterator& operator++() { ++current; return *this; }
  move_iterator& operator--() { --current; return *this; }
  move_iterator& operator++(int) { move_iterator temp = *this; ++current; return temp; }
  move_iterator& operator--(int) { move_iterator temp = *this; --current; return temp; }
  move_iterator operator+ (difference_type n) const { return move_iterator(current+n); }
  move_iterator operator- (difference_type n) const { return move_iterator(current-n); }
  move_iterator operator+= (difference_type n) { current+=n; return *this; }
  move_iterator operator-= (difference_type n) { current-=n; return *this; }
  auto operator[](difference_type n) const -> decltype(std::move(current[n]))
  { return std::move(current[n]); }
};
}