Namespaces
Variants

std::experimental::ranges:: equal

From 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 Elementgruppen identisch sind
(Funktions-Template)
findet das erste Element, das bestimmte Kriterien erfüllt
(Funktions-Template)
gibt true zurück, falls ein Bereich lexikographisch kleiner als ein anderer ist
(Funktions-Template)
findet die erste Position, an der zwei Bereiche sich unterscheiden
(Funktions-Template)
sucht nach einem Bereich von Elementen
(Funktions-Template)