Namespaces
Variants

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

From cppreference.net
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) (seit C++20)
constexpr decltype ( auto ) operator * ( ) const
requires /*dereferenceable*/ < const I > ;
(2) (seit C++20)
constexpr auto operator - > ( ) const
requires /* siehe Beschreibung */ ;
(3) (seit C++20)
Hilfstypen
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) ( nur zur Darstellung* )

Gibt einen Zeiger oder eine Referenz auf das aktuelle Element zurück, oder einen Proxy, der es hält.

Das Verhalten ist undefiniert, falls das zugrundeliegende std::variant Mitgliedsobjekt var kein Objekt vom Typ I enthält, d.h. std:: holds_alternative < I > ( var ) gleich false ist.

Sei it der Iterator vom Typ I , der von var gehalten wird, also std :: get < I > ( var ) .

1,2) Gibt das Ergebnis der Dereferenzierung von it zurück.
3) Gibt einen Zeiger oder zugrundeliegenden Iterator auf das aktuelle Element zurück, oder einen Proxy, der es hält:
  • Entspricht return it ; , falls I ein Zeigertyp ist oder der Ausdruck it. operator - > ( ) wohlgeformt ist.
  • Andernfalls entspricht auto && tmp = * it ; return std:: addressof ( tmp ) ; , falls std:: iter_reference_t < I > ein Referenztyp ist.
  • Andernfalls entspricht return proxy ( * it ) ; , wobei proxy eine nur zur Darstellung dienende Klasse ist (4) .
Der Ausdruck in der requires -Klausel ist äquivalent zu
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 >>

) .

Inhaltsverzeichnis

Parameter

(keine)

Rückgabewert

1,2) Referenz auf das aktuelle Element oder temporären Prvalue. Entspricht * it .
3) Zeiger oder Iterator auf das aktuelle Element oder Proxy, der es wie oben beschrieben hält.

Beispiel

Diesen Code ausführen 
#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';
}

Ausgabe: 

(3.14,2) 3.14

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3574 C++20 variant war vollständig constexpr (P2231R1), aber common_iterator war es nicht ebenfalls constexpr gemacht
LWG 3595 C++20 Funktionen des Proxy-Typs hatten kein constexpr und noexcept hinzugefügt
LWG 3672 C++20 operator-> könnte in üblichen Fällen per Referenz zurückgeben gibt immer per Wert zurück

Siehe auch

Konstruiert einen neuen common_iterator
(Öffentliche Mitgliedsfunktion)