Namespaces
Variants

operator==,<=> (std::counted_iterator)

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::counted_iterator
template < std:: common_with < I > I2 >

friend constexpr bool operator == (

const counted_iterator & x, const counted_iterator < I2 > & y ) ;
(1) (seit C++20)
template < std:: common_with < I > I2 >

friend constexpr strong_ordering operator <=> (

const counted_iterator & x, const counted_iterator < I2 > & y ) ;
(2) (seit C++20)

Vergleicht die zugrundeliegenden Längen (d.h. Abstände zum Ende).

1) Prüft, ob die zugrundeliegenden Längen gleich sind.
2) Vergleicht die zugrundeliegenden Längen mit dem Operator <=> .

Das Verhalten ist undefiniert, falls x und y nicht auf Elemente derselben Sequenz zeigen. Das heißt, es muss ein n existieren, sodass std:: next ( x. base ( ) , x. count ( ) + n ) und std:: next ( y. base ( ) , y. count ( ) + n ) auf dasselbe Element verweisen.

Die < -, <= -, > -, >= - und != -Operatoren werden synthetisiert aus operator <=> beziehungsweise operator == .

Diese Funktionsvorlage ist für gewöhnliches unqualified oder qualified lookup nicht sichtbar und kann nur durch argument-dependent lookup gefunden werden, wenn std::counted_iterator<I> eine assoziierte Klasse der Argumente ist.

Inhaltsverzeichnis

Parameter

x, y - Iterator-Adapter

Rückgabewert

1) x. count ( ) == y. count ( )
2) y. count ( ) <=> x. count ( )

Hinweise

Da der length abwärts zählt, nicht aufwärts, ist die Reihenfolge der Argumente von operator <=> im zugrunde liegenden Vergleichsausdruck umgekehrt, d.h. y ist lhs , x ist rhs .

Beispiel

Diesen Code ausführen 
#include <initializer_list>
#include <iterator>
int main()
{
    static constexpr auto v = {1, 2, 3, 4, 5, 6};
    constexpr std::counted_iterator<std::initializer_list<int>::iterator>
        it1{v.begin(), 5},
        it2{v.begin(), 5},
        it3{v.begin() + 1, 4},
        it4{v.begin(), 0};
    static_assert(it1 == it2);
    static_assert(it2 != it3);
    static_assert(it2 <  it3);
    static_assert(it1 <= it2);
    static_assert(it3 != std::default_sentinel);
    static_assert(it4 == std::default_sentinel);
//  it2 == std::counted_iterator{v.begin(), 4}; // UB: Operanden beziehen sich nicht auf
                                                // Elemente derselben Sequenz
}

Siehe auch

(C++20)
prüft, ob die Entfernung zum Ende gleich ​0​ ist
(Funktionsschablone)
(C++20)
erhöht den Iterator
(Funktionsschablone)
(C++20)
berechnet die Entfernung zwischen zwei Iterator-Adaptoren
(Funktionsschablone)