Namespaces
Variants

    std::experimental::ranges:: equal

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    **Erklärung:** - Alle HTML-Tags, Attribute und C++-spezifischen Begriffe wurden unverändert belassen - Der C++-Code innerhalb der `` Tags wurde nicht übersetzt - Die numerische Kennzeichnung "(2)" und die Versionsmarkierung "(ranges TS)" wurden nicht übersetzt, da sie zur technischen Dokumentation gehören - Die Formatierung und Struktur der HTML-Tabelle wurde vollständig beibehalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
    template < InputIterator I1, Sentinel < I1 > S1, InputIterator I2, Sentinel < I2 > S2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert IndirectlyComparable < I1, I2, Pred, Proj1, Proj2 >
    bool equal ( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires IndirectlyComparable < ranges:: iterator_t < R1 > , ranges:: iterator_t < R2 > ,
    Pred, Proj1, Proj2 >
    bool equal ( R1 && r1, R2 && r2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(2) (ranges TS)
    template < InputIterator I1, Sentinel < I1 > S1, class I2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < I1, std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool equal ( I1 first1, S1 last1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(3) (ranges TS)
    (veraltet)
    template < InputRange R1, class I2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < ranges:: iterator_t < R1 > , std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool equal ( R1 && r1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(4) (ranges TS)
    (veraltet)
    1) Gibt true zurück, wenn der Bereich [ first1 , last1 ) gleich dem Bereich [ first2 , last2 ) ist, andernfalls false .
    2) Gleich wie (1) , verwendet jedoch r1 als ersten Quellbereich und r2 als zweiten Quellbereich, als ob ranges:: begin ( r1 ) als first1 , ranges:: end ( r1 ) als last1 , ranges:: begin ( r2 ) als first2 , und ranges:: end ( r2 ) als last2 verwendet würde.
    3) Gleich wie (1) , mit der Ausnahme, dass der zweite Bereich als beendet betrachtet wird, wenn entweder der erste Bereich erschöpft ist oder die erste Nichtübereinstimmung erkannt wird. Entspricht return last1 == ranges:: mismatch ( first1, last1, std:: forward < I2 > ( first2_ ) , comp, proj1, proj2 ) . in1 ( ) ;
    4) Gleich wie (3) , verwendet jedoch r1 als ersten Quellbereich, als ob ranges:: begin ( r1 ) als first1 und ranges:: end ( r1 ) als last1 verwendet würde.

    Zwei Bereiche werden als gleich betrachtet, wenn sie die gleiche Anzahl an Elementen haben und für jeden Iterator i im Bereich [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) true ist.

    Ungeachtet der oben dargestellten Deklarationen sind die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Daher ist das Programm wahrscheinlich nicht portabel, wenn explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden.

    Inhaltsverzeichnis

    Parameter

    first1, last1 - der erste Bereich der Elemente
    r1 - der erste Bereich der Elemente
    first2, last2 - der zweite Bereich der Elemente
    r2 - der zweite Bereich der Elemente
    first2_ - der Anfang des zweiten Bereichs der Elemente
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj1 - Projektion, die auf die Elemente im ersten Bereich angewendet wird
    proj2 - Projektion, die auf die Elemente im zweiten Bereich angewendet wird

    Rückgabewert

    true wenn die beiden Bereiche gleich sind, andernfalls wird false zurückgegeben.

    Hinweise

    ranges::equal sollte nicht verwendet werden, um die Bereiche zu vergleichen, die von den Iteratoren aus std::unordered_set , std::unordered_multiset , std::unordered_map oder std::unordered_multimap gebildet werden, da die Reihenfolge, in der die Elemente in diesen Containern gespeichert sind, unterschiedlich sein kann, selbst wenn beide Container dieselben Elemente speichern.

    Beim Vergleich gesamter Container auf Gleichheit, operator== für den entsprechenden Container werden normalerweise bevorzugt.

    Komplexität

    1,2) Falls SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > erfüllt ist und last1 - first1 ! = last2 - first2 , keine Anwendungen des Prädikats und der Projektionen. Andernfalls höchstens min( last1 - first1 , last2 - first2 ) Anwendungen des Prädikats und jeder Projektion.
    3,4) Höchstens last1 - first1 Anwendungen des Prädikats und jeder Projektion.

    Mögliche Implementierung 

    namespace detail 
{
    template<InputIterator I1, SizedSentinel<I1> S1,
             InputIterator I2, SizedSentinel<I1> S2>
    bool check_size(I1& first1, S1& last1, I2& first2, S2& last2)
    {
        return last1 - first1 != last2 - first2;
    }
    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I1> S2>
    bool check_size(I1& first1, S1& last1, I2& first2, S2& last2)
    {
        return false;
    }
}
template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
         class Pred = ranges::equal_to<>, 
         class Proj1 = ranges::identity, class Proj2 = ranges::identity>
    requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
bool equal(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{},
           Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{}) 
{
    if (detail::check_size(first1, last1, first2, last2))
        return false;
    for (; first1 != last1 && first2 != last2; (void) ++first1, (void)++first2)
        if (!ranges::invoke(pred, ranges::invoke(proj1, *first1), 
                                  ranges::invoke(proj2, *first2)))
            return false;
    return first1 == last1 && first2 == last2;
}

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    		 bestimmt, ob zwei Mengen von Elementen gleich sind
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		findet das erste Element, das bestimmte Kriterien erfüllt
    (Funktionsschablone)
    		gibt true zurück, wenn ein Bereich lexikografisch kleiner ist als ein anderer
    (Funktionsschablone)
    		findet die erste Position, an der sich zwei Bereiche unterscheiden
    (Funktionsschablone)
    		sucht nach einem Bereich von Elementen
    (Funktionsschablone)