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 common_iterator & operator ++ ( ) ;
(1) (seit C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (seit C++20)
Hilfstypen
class /*postfix_proxy*/ {

std:: iter_value_t < I > keep_ ;
constexpr postfix_proxy ( std:: iter_reference_t < I > && x )
: keep_ ( std:: forward < std:: iter_reference_t < I >> ( x ) ) { }
public :
constexpr const std:: iter_value_t < I > & operator * ( ) const noexcept {
return keep_ ;
}

} ;
(3) ( nur zur Darstellung* )

Erhöht den zugrundeliegenden Iterator.

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) Erhöht den Wert vorab um eins. Entspricht ++ it ; return * this ; .
2) Post-Inkrement um eins:
  • Entspricht: auto tmp = * this ; ++* this ; return tmp ; , falls I das Konzept forward_iterator modelliert.
  • Entspricht: return it ++ ; , falls die Variablendefinition auto && ref = * it ++ ; wohlgeformt ist, oder entweder
false ist.
  • Entspricht: postfix_proxy p ( ** this ) ; ++* this ; return p ; andernfalls, wobei postfix_proxy ein nur zur Darstellung dienender Hilfstyp ist (3) .

Inhaltsverzeichnis

Parameter

(keine)

Rückgabewert

1) * this
2) Eine Kopie von * this die vor der Änderung erstellt wurde, oder ein Ergebnis der Post-Inkrementierung des zugrundeliegenden Iterators, oder ein Proxy, der den Wert des aktuellen Elements speichert, wie oben beschrieben.

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <iterator>
int main()
{
    const auto il = {1, 2, 3, 4, 5, 6};
    using CI = std::common_iterator<
                   std::counted_iterator<std::initializer_list<int>::iterator>,
                   std::default_sentinel_t
                   >;
    CI first{std::counted_iterator{std::begin(il), std::ssize(il) - 2}};
    for (; first != std::default_sentinel; ++first)
        std::cout << *first << ' ';
    std::cout << '\n';
}

Ausgabe: 

1 2 3 4

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
P2259R1 C++20 Post-Increment könnte sein Ergebnis in mehr Situationen verwerfen Eine Proxy-Klasse wird zur Erhaltung des Ergebnisses verwendet
LWG 3546 C++20 Initialisierung des Proxy-Objekts war manchmal fehlerhaft Situation und Definition angepasst
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 enthielten kein constexpr und noexcept hinzugefügt

Siehe auch

berechnet die Distanz zwischen zwei Iterator-Adaptoren
(Funktions-Template)