std::ranges...w::iterator(3)

💖 NAME 💖

std::ranges::repeat_view::iterator — yeah bestie, that's the whole name, it's the iterator type for std::ranges::repeat_view, brought to you by the C++ Standard Library manual ✨ (and yes, the manual name is literally "C++ Standard Library", we're fancy like that 💅)

---

🌈 SYNOPSIS 🌈

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

The return type of repeat_view::begin. That's the entire vibe, no cap 🫶

---

🎀 MEMBER TYPES 🎀

• index-type — ok so it's std::ptrdiff_t if Bound is the same as std::unreachable_sentinel_t. Otherwise? It's Bound. Simple as that. (exposition-only member type*)
• iterator_concept — std::random_access_iterator_tag 💅
• iterator_category — std::random_access_iterator_tag, yeah same one, she's consistent
• value_type — W
• difference_type — so it's /*index-type*/ if /*is-signed-like*/</*index-type*/> is true, and /*iota-diff-t*/(/*index-type*/) otherwise, where /*iota-diff-t*/ has the same meaning as in iota_view. Iykyk 🧚

---

🍓 DATA MEMBERS 🍓

• value_ (private) — a pointer of type const W* that holds the pointer to the value to 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 (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*/(                           (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. Heads up bestie: 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_;. That's it, she dereferences and serves 💅

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

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

Equivalent to return *(*this + n);. Index math, iconic behavior 👑

🎀 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;.

Post-increment lowkey makes a copy first, that's just how she rolls 💀

🦋 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. Don't be out here violating that, fr fr 🫶

🧚 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. Same energy, opposite direction ✨

---

🔥 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     (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== — she doesn't need her own, she's built different 💅

Ok so listen: 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. ADL only, bestie, that's the rule 📌

🌈 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;. Both orders work, she's flexible like that 🦋

Same caveat as before: 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,  (2) (since C++23)
    const /*iterator*/& y );

1. Equivalent to i -= n; return i;.
2. Equivalent to return static_cast<difference_type>(x.current_) - static_cast<difference_type>(y.current_);.

And once more for the people in the back: 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. Always. Periodt. 💅🔥

---

Ok that's the whole page bestie, you ate that 🫶 This masterpiece came to you courtesy of http://cppreference.com, dated 2024.06.10 — go off, and remember: no cap, only C++23 ✨🎀💖