NAME¶

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

Synopsis¶

struct /*iterator*/; (since C++23)
(exposition only*)

The return type of repeat_view::begin.

Member types¶

Member type Definition
* std::ptrdiff_t, if Bound is the same as
index-type std::unreachable_sentinel_t. Otherwise,
* Bound.
(exposition-only member type*)
iterator_concept std::random_access_iterator_tag
iterator_category std::random_access_iterator_tag
value_type W
* /*index-type*/, if /*is-signed-like*/</*index-type*/> is true,
difference_type * /*iota-diff-t*/(/*index-type*/) otherwise, where
/*iota-diff-t*/ has the same meaning as in iota_view.

Data members

Member name Definition
A pointer of type const W* that holds the pointer to the value to
value_ (private) repeat.
(exposition-only member object*)
current_ (private) An object of type /*index-type*/ that holds the current position.
(exposition-only member object*)

Member functions¶

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

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

/*iterator*/() = default; (1) (since C++23)
constexpr explicit /*iterator*/( (2) (since C++23)
const W* value, /*index-type*/ b = /*index-type*/() ); (exposition only*)

1) Value initializes the 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== compares the underlying iterators
operator<=> (function)
(C++23)
operator+ performs iterator arithmetic
operator- (function)
(C++23)

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

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

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, (1) (since C++23)
difference_type n );
friend constexpr /*iterator*/ operator+( difference_type n, (2) (since C++23)
/*iterator*/ i );

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, (1) (since C++23)
difference_type n );
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.