An LegacyInputIterator is an LegacyIterator that can read from the pointedto element. LegacyInputIterators only guarantee validity for single pass algorithms: once an LegacyInputIterator i
has been incremented, all copies of its previous value may be invalidated.
The type It
satisfies LegacyInputIterator if.
It
satisfies LegacyIterator It
satisfies EqualityComparable And, given.
i
and j
, values of type It
or const It
reference
, the type denoted by std::iterator_traits<It>::reference
value_type
, the type denoted by std::iterator_traits<It>::value_type
The following expressions must be valid and have their specified effects.
Expression  Return  Equivalent expression  Notes 

i != j  contextually convertible to bool
 !(i == j) 
Precondition: (i, j) is in the domain of == . 
*i 
reference , convertible to value_type
 If i == j and (i, j) is in the domain of == then this is equivalent to *j .  Precondition: The expression 
i>m  (*i).m 
Precondition: i is dereferenceable. 

++i  It&  Precondition: Postcondition: Postcondition: Any copies of the previous value of 

(void)i++  (void)++i  
*i++  convertible to value_type 
value_type x = *i; ++i; return x; 
"in the domain of ==
" means equality comparison is defined between the two iterator values. For input iterators, equality comparison does not need to be defined for all values, and the set of the values in the domain of ==
may change over time.
The reference
type for an input iterator that is not also a LegacyForwardIterator does not have to be a reference type: dereferencing an input iterator may return a proxy object or value_type
itself by value (as in the case of std::istreambuf_iterator
).
ConceptFor the definition of
where the expositiononly concept  (since C++20) 
specifies that a type is an input iterator, that is, its referenced values can be read and it can be both pre and postincremented (concept) 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/named_req/InputIterator