std::basic_const_iterator - cppreference.com (original) (raw)
std::basic_const_iterator
std::basic_const_iterator is an iterator adaptor which behaves exactly like the underlying iterator (which must be at least an LegacyInputIterator or model input_iterator), except that dereferencing converts the value returned by the underlying iterator as immutable. Specializations of std::basic_const_iterator are constant iterators, that is, the iterator can never be used as an output iterator because modifying elements is not allowed.
Contents
- 1 Member types
- 2 Member objects
- 3 Member functions
- 4 Non-member functions
- 5 Helper classes
- 6 Helper alias templates
- 7 Helper function templates
- 8 Notes
- 9 Example
- 10 Defect reports
[edit] Member types
| Member type | Definition |
|---|---|
| iterator_category(conditionally present) | If Iter models forward_iterator: member iterator_category is the same type as std::iterator_traits<Iter>::iterator_category. Otherwise, there is no member iterator_category. |
| iterator_concept | std::contiguous_iterator_tag, if Iter models contiguous_iterator; std::random_access_iterator_tag, if Iter models random_access_iterator; std::bidirectional_iterator_tag, if Iter models bidirectional_iterator; std::forward_iterator_tag, if Iter models forward_iterator; std::input_iterator_tag otherwise. |
| value_type | std::iter_value_t<Iter> |
| difference_type | std::iter_difference_t<Iter> |
| reference (private) | std::iter_const_reference_t<Iter>(exposition-only member type*) |
[edit] Member objects
| Member name | Definition |
|---|---|
| current (private) | the underlying iterator from which base() copies or moves(exposition-only member object*) |
[edit] Member functions
| (constructor) | constructs a new basic_const_iterator (public member function) [edit] |
|---|---|
| base | accesses the underlying iterator (public member function) [edit] |
| operator*operator-> | accesses the pointed-to element (public member function) [edit] |
| operator[] | accesses an element by index (public member function) [edit] |
| operator++operator++(int)operator+=operator--operator--(int)operator-= | advances or decrements the iterator (public member function) [edit] |
| operator constant-iterator | converts into any constant iterator to which an underlying iterator can be convertible (public member function) [edit] |
| operator==operatoroperator<=operator>=operator<=> | compares the underlying iterators (public member function) [edit] |
[edit] Non-member functions
[edit] Helper classes
[edit] Helper alias templates
If I models constant-iterator (an exposition-only concept), then const_iterator<I> denotes a type I. Otherwise, basic_const_iterator<I>.
| template< std::semiregular S > using const_sentinel = /* see description */; | | (since C++23) | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | ------------- |
If S models input_iterator, then const_sentinel<S> denotes a type const_iterator<S>. Otherwise, S.
[edit] Helper function templates
| template< std::input_iterator T > constexpr const_iterator<T> make_const_iterator( I it ) { return it; } | | (since C++23) | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ------------- | | template< std::semiregular S > constexpr const_sentinel<S> make_const_sentinel( S s ) { return s; } | | (since C++23) |
[edit] Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
| __cpp_lib_ranges_as_const | 202207L | (C++23) | std::basic_const_iterator |
| 202311L | (C++23)(DR) | std::basic_const_iterator should follow its underlying type's convertibility |
[edit] Example
#include #include #include int main() { std::vector v{1, 2, 3}; std::vector::iterator i = v.begin(); *i = 4; // OK, v[0] == 4 now i[1] = 4; // OK, the same as *(i + 1) = 4; auto ci = std::make_const_iterator(i); assert(*ci == 4); // OK, can read the underlying object assert(ci[0] == 4); // OK, ditto // *ci = 13; // Error: location is read-only // ci[0] = 13; // Error: ditto ci.base()[0] = 42; // OK, underlying iterator is writable assert(*ci == 42); // OK, underlying location v[0] was modified }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| P2836R1 | C++23 | basic_const_iterator doesn't follow its underlying type's convertibility | conversion operator provided |