Difference between revisions of "cpp/named req/InputIterator"
m ("lvalue of type It" istead of "value of type It&") |
m (an lvalue) |
||
| Line 11: | Line 11: | ||
And, given | And, given | ||
* {{c|i}} and {{c|j}}, values of type {{c|It}} or {{c|const It}} | * {{c|i}} and {{c|j}}, values of type {{c|It}} or {{c|const It}} | ||
| − | * {{c|r}}, | + | * {{c|r}}, an lvalue of type {{c|It}} |
* {{c|reference}}, the type denoted by {{c|std::iterator_traits<It>::reference}} | * {{c|reference}}, the type denoted by {{c|std::iterator_traits<It>::reference}} | ||
* {{c|value_type}}, the type denoted by {{c|std::iterator_traits<It>::value_type}} | * {{c|value_type}}, the type denoted by {{c|std::iterator_traits<It>::value_type}} | ||
Revision as of 11:14, 25 October 2022
A LegacyInputIterator is a LegacyIterator that can read from the pointed-to element. LegacyInputIterators only guarantee validity for single pass algorithms: once a LegacyInputIterator i has been incremented, all copies of its previous value may be invalidated.
Contents |
Requirements
The type It satisfies LegacyInputIterator if
- The type It satisfies LegacyIterator
- The type It satisfies EqualityComparable
And, given
- i and j, values of type It or const It
- r, an lvalue of type 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 type | 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: i is dereferenceable. The expression (void)*i, *i is equivalent to *i. |
| i->m | (*i).m | Precondition: i is dereferenceable. | |
| ++r | It& |
Precondition: r is dereferenceable. Postcondition: r is dereferenceable or r is past-the-end. Postcondition: Any copies of the previous value of r are no longer required to be either dereferenceable or to be in the domain of ==. | |
| (void)r++ | (void)++r | ||
| *r++ | convertible to value_type | value_type x = *r; ++r; |
Notes
"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 std::iterator_traits, the following exposition-only concept is defined.
where the exposition-only concept |
(since C++20) |
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 98 | C++98 | the return type of *i++ was value_type | it can be any type convertible to value_type |
See also
| (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 post-incremented (concept) |
| Iterator library | provides definitions for iterators, iterator traits, adaptors, and utility functions |
