table of contents
std::common_iterator::operator*,->(3) | C++ Standard Libary | std::common_iterator::operator*,->(3) |
NAME¶
std::common_iterator::operator*,-> - std::common_iterator::operator*,->
Synopsis¶
constexpr decltype(auto) operator*(); (1) (since
C++20)
constexpr decltype(auto) operator*() const (2) (since C++20)
requires /*dereferenceable*/<const I>;
constexpr auto operator->() const (3) (since C++20)
requires /* see description */;
Helper types¶
class /*proxy*/ {
std::iter_value_t<I> keep_;
constexpr proxy(std::iter_reference_t<I>&& x)
: keep_(std::move(x)) {}
public: (4) (exposition only*)
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).
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->() 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).
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 also made constexpr
common_iterator was not
LWG 3595 C++20 functions of the proxy type lacked added
constexpr and noexcept
LWG 3672 C++20 operator-> might return by reference in always returns by
usual cases value
See also¶
constructor constructs a new iterator adaptor
(C++20) (public member function)
2024.06.10 | http://cppreference.com |