cppdraft_translate/cppdraft/input/iterators.md

[input.iterators]

24 Iterators library [iterators]

24.3 Iterator requirements [iterator.requirements]

24.3.5 C++17 iterator requirements [iterator.cpp17]

24.3.5.3 Input iterators [input.iterators]

1

#

A class or pointer typeX meets the requirements of an input iterator for the value typeT ifX meets the Cpp17Iterator ([iterator.iterators]) andCpp17EqualityComparable (Table 28) requirements and the expressions in Table 79 are valid and have the indicated semantics.

2

#

In Table 79, the termthe domain of == is used in the ordinary mathematical sense to denote the set of values over which== is (required to be) defined.

This set can change over time.

Each algorithm places additional requirements on the domain of== for the iterator values it uses.

These requirements can be inferred from the uses that algorithm makes of == and !=.

[Example 1:

The call find(a,b,x) is defined only if the value of a has the property p defined as follows:b has property p and a value i has property p if (i==x) or if (i!=x and++i has propertyp).

— end example]

Table 79 — Cpp17InputIterator requirements (in addition to Cpp17Iterator) [tab:inputiterator]

🔗 Expression	Return type	Operational	Assertion/note
🔗		semantics	pre-/post-condition
🔗 a != b	decltype(a != b) models boolean-testable	!(a == b)	Preconditions: (a, b) is in the domain of ==.
🔗 *a	reference, convertible to T		Preconditions: a is dereferenceable. The expression (void)*a, *a is equivalent to *a. If a == b and (a, b) is in the domain of == then *a is equivalent to *b.
🔗 a->m		(*a).m	Preconditions: a is dereferenceable.
🔗 ++r	X&		Preconditions: r is dereferenceable. Postconditions: r is dereferenceable or r is past-the-end; any copies of the previous value of r are no longer required to be dereferenceable nor to be in the domain of ==.
🔗 (void)r++			equivalent to (void)++r
🔗 *r++	convertible to T	{ T tmp = *r; ++r; return tmp; }

3

#

Recommended practice: The implementation of an algorithm on input iterators should never attempt to pass through the same iterator twice; such an algorithm should be a single pass algorithm.

[Note 1:

For input iterators, a == b does not imply ++a == ++b.

(Equality does not guarantee the substitution property or referential transparency.)

Value type T is not required to be a Cpp17CopyAssignable type (Table 34).

Such an algorithm can be used with istreams as the source of the input data through theistream_iterator class template.

— end note]