W3cubDocs

/C++

std::ranges::repeat_view<W, Bound>::iterator 

struct /*iterator*/;
 (1) (since C++23)
Helper alias templates 
template< class I >
using /*iota-diff-t*/ = /* see below */;  // exposition only
 (2) (since C++23)
1) The return type of repeat_view::begin. The name of this class (shown here as /*iterator*/) is unspecified.
2) The exposition-only alias template /*iota-diff-t*/ calculates the difference type for both iterator types and integer-like types.
  • If W is not an integral type, or if it is an integral type and sizeof(std::iter_difference_t<I>) is greater than sizeof(I), then /*iota-diff-t*/<I> is std::iter_difference_t<I>.
  • Otherwise, /*iota-diff-t*/<I> is a signed integer type of width greater than the width of I if such a type exists.
  • Otherwise, I is one of the widest integral types, and /*iota-diff-t*/<I> is an unspecified signed-integer-like type of width not less than the width of I. It is unspecified whether /*iota-diff-t*/<I> models weakly_incrementable in this case.

Member types

Member type Definition
index-type (private)

The name is for exposition only.
iterator_concept std::random_access_iterator_tag
iterator_category std::random_access_iterator_tag
value_type W
difference_type
  • /*index-type*/, if /*is-signed-like*/</*index-type*/> is true,
  • /*iota-diff-t*/(/*index-type*/) otherwise.

Data members

Typical implementation of this iterator type contains two data members:

  • value_ of type const W* that holds the pointer to the value to repeat;
  • current_ of type /*index-type*/ that holds the current position.

These names are exposition only.

Member functions

(constructor)
(C++23)
 constructs an iterator
(public member function)
operator*
(C++23)
 returns the current subrange
(public member function)
operator[]
(C++23)
 accesses an element by index
(public member function)
operator++operator++(int)operator--operator--(int)operator+=operator-=
(C++23)
 advances or decrements the underlying iterator
(public member function)

std::ranges::repeat_view::iterator::iterator 

/*iterator*/() = default;
 (1) (since C++23) 
constexpr explicit /*iterator*/(    // exposition only
    const W* value, /*index-type*/ b = /*index-type*/() );
 (2) (since C++23)
1) Value initializes the exposition-only data members:
  • value_ with nullptr_t via its default member initializer;
  • index_ via its default member initializer (= /*index-type*/()).
2) Value initializes value_ with value and bound_ with b. If Bound is not std::unreachable_sentinel_t then b must be non-negative. This constructor is not a part of the public interface.

std::ranges::repeat_view::iterator::operator*

constexpr const W& operator*() const noexcept;
 (since C++23)

Equivalent to return *value_;.

std::ranges::repeat_view::iterator::operator[]

constexpr const W& operator[]( difference_type n ) const noexcept;
 (since C++23)

Equivalent to return *(*this + n);.

std::ranges::repeat_view::iterator::operator++

constexpr /*iterator*/& operator++();
 (1) (since C++23) 
constexpr void operator++(int);
 (2) (since C++23)
1) Equivalent to ++current_; return *this;.
2) Equivalent to auto tmp = *this; ++*this; return tmp;.

std::ranges::repeat_view::iterator::operator--

constexpr /*iterator*/& operator--();
 (1) (since C++23) 
constexpr /*iterator*/ operator--(int);
 (2) (since C++23)
1) Equivalent to --current_; return *this;. If Bound is not std::unreachable_sentinel_t then bound_ must be positive.
2) Equivalent to auto tmp = *this; --*this; return tmp;.

std::ranges::repeat_view::iterator::operator+=

constexpr /*iterator*/& operator+=( difference_type n );
 (since C++23)

Equivalent to current_ += n; return *this;. If Bound is not std::unreachable_sentinel_t then (bound_ + n) must be non-negative.

std::ranges::repeat_view::iterator::operator-=

constexpr /*iterator*/& operator-=( difference_type n );
 (since C++23)

Equivalent to current_ -= n; return *this;. If Bound is not std::unreachable_sentinel_t, then (bound_ - n) must be non-negative.

Non-member functions

operator==operator<=>
(C++23)
 compares the underlying iterators
(function)
operator+operator-
(C++23)
 performs iterator arithmetic
(function)

operator==, <=>(std::ranges::repeat_view::iterator)

friend constexpr bool operator==( const /*iterator*/& x, const /*iterator*/& y );
 (1) (since C++23) 
friend constexpr auto operator<=>( const /*iterator*/& x, const /*iterator*/& y );
 (2) (since C++23)
1) Equivalent to x.current_ == y.current_.
2) Equivalent to x.current_ <=> y.current_.

The != operator is synthesized from operator==.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator+(std::ranges::repeat_view::iterator)

friend constexpr /*iterator*/ operator+( /*iterator*/ i, difference_type n );
 (1) (since C++23) 
friend constexpr /*iterator*/ operator+( difference_type n, /*iterator*/ i );
 (2) (since C++23)

Equivalent to i += n; return i;.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator-(std::ranges::repeat_view::iterator)

friend constexpr /*iterator*/ operator-( /*iterator*/ i, difference_type n );
 (1) (since C++23) 
friend constexpr difference_type operator-( const /*iterator*/& x,
                                            const /*iterator*/& y );
 (2) (since C++23)
1) Equivalent to i -= n; return i;.
2) Equivalent to return static_cast<difference_type>(x.current_) - static_cast<difference_type>(y.current_);.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

Notes

iterator is always random_access_iterator.

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/repeat_view/iterator