std::common_iterator<I,S>::operator*,->

From cppreference.com
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11)(C++14)
(C++14)(C++14)
(C++11)(C++14)
(C++14)(C++14)
(C++17)(C++20)
(C++17)
(C++17)
std::common_iterator
constexpr decltype( auto ) operator* ( ) ;
(1) (since C++20)
constexpr decltype( auto ) operator* ( ) const
    requires /*dereferenceable*/ < const I> ;
(2) (since C++20)
constexpr auto operator- > ( ) const
    requires /* see description */ ;
(3) (since C++20)
Helper types
class /*proxy*/ {

std::iter_value_t <I> keep_;
constexpr proxy( std::iter_reference_t <I> && x)
: keep_(std:: move (x) ) { }
public :
constexpr const std::iter_value_t <I> * operator- > ( ) const noexcept {
return std::addressof (keep_) ;
}

} ;
(4) (exposition only*)

Returns pointer or reference to the current element, or a proxy holding it.

The behavior is undefined if the underlying std::variant member object var does not hold an object of type I, i.e. std::holds_alternative <I> (var) is equal to false

Let it denote the iterator of type I held by var, that is std::get<I>(var)

1,2) Returns the result of dereferencing it.
3) Returns a pointer or underlying iterator to the current element, or a proxy holding it:
  • Equivalent to return it;, if I is a pointer type or if the expression it.operator->()
  • Otherwise, equivalent to auto && tmp = *it; return std::addressof (tmp) ; , if std::iter_reference_t<I>
  • Otherwise, equivalent to return proxy(*it);, where proxy is an exposition only class (4)
The expression in the requires-clause is equivalent to
std::indirectly_readable < const I> && (

requires( const I& i) { i.operator - > ( ) ; } ||
std::is_reference_v < std::iter_reference_t <I>> ||
std::constructible_from < std::iter_value_t <I>, std::iter_reference_t <I>>

)

Parameters

(none)

Return value

1,2) Reference to the current element, or prvalue temporary. Equivalent to *it.
3) Pointer or iterator to the current element or proxy holding it as described above.

Example

Run this code
#include <complex>
#include <initializer_list>
#include <iostream>
#include <iterator>
 
using std::complex_literals::operator""i;
 
int main()
{
    const auto il = {1i, 3.14 + 2i, 3i, 4i, 5i};
 
    using CI = std::common_iterator<
        std::counted_iterator<decltype(il)::iterator>,
        std::default_sentinel_t>;
 
    CI ci{std::counted_iterator{std::next(begin(il), 1), std::ssize(il) - 1}};
 
    std::cout << *ci << ' ' << ci->real() << '\n';
}

Output: 

(3.14,2) 3.14

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 3574 C++20 variant was fully constexpr (P2231R1) but common_iterator was not also made constexpr
LWG 3595 C++20 functions of the proxy type lacked constexpr and noexcept added
LWG 3672 C++20 operator-> might return by reference in usual cases always returns by value

See also

(C++20)
 constructs a new iterator adaptor
(public member function)
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/common_iterator/operator*&oldid=159364