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

constexpr decltype(auto) operator*();

constexpr decltype(auto) operator*() const
    requires /*dereferenceable*/<const I>;

constexpr auto operator->() const
    requires /* see description */;

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_);
    }
};

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).

• Equivalent to return it;, if I is a pointer type or if the expression it.operator->() is well-formed.
• Otherwise, equivalent to auto&& tmp = *it; return std::addressof(tmp);, if std::iter_reference_t<I> is a reference type.
• Otherwise, equivalent to return proxy(*it);, where proxy is an exposition only class (4).

Parameters

(none)

Return value

Example

#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';
}

(3.14,2) 3.14

Defect reports

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

See also