Namensräume
Varianten
Aktionen

std::experimental::ranges::equal

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
C++
 
Experimentell
 
Bereiche (Ranges)
 
Algorithmen-Bibliothek
Nicht-modifizierende Sequenzoperationen
                              
Modifizierende Sequenzoperationen
                              
Partitionierungsoperationen
Sortieroperationen
Binäre Suchoperationen
Mengenoperationen (auf sortierten Bereichen)
                              
Heapoperationen
Minimum/Maximum-Operationen
Permutationen
 
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{} );
 (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 >
    requires 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 >
    requires 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, und andernfalls false.
2) Dasselbe wie (1), aber verwendet 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ürden.
3) Dasselbe wie (1), außer dass der zweite Bereich als beendet betrachtet wird, wenn entweder der erste Bereich erschöpft ist oder der erste Unterschied erkannt wird. Entspricht return last1 == ranges::mismatch(first1, last1, std::forward<I2>(first2_), comp, proj1, proj2).in1();
4) Dasselbe wie (3), verwendet aber r1 als ersten Quellbereich, als ob ranges::begin(r1) als first1 und ranges::end(r1) als last1 verwendet würden.

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

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

Inhalt

[bearbeiten] 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

[bearbeiten] Rückgabewert

true, wenn die beiden Bereiche gleich sind, andernfalls gibt false zurück.

[bearbeiten] Anmerkungen

ranges::equal sollte nicht verwendet werden, um Bereiche zu vergleichen, die durch 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, auch wenn die beiden Container die gleichen Elemente enthalten.

Beim Vergleichen ganzer Container auf Gleichheit wird in der Regel der operator== für die entsprechenden Container bevorzugt.

[bearbeiten] Komplexität

1,2) Wenn SizedSentinel<S1, I1> && SizedSentinel<S2, I2> erfüllt ist und last1 - first1 != last2 - first2 gilt, keine Anwendungen der Prädikats- und Projektionsfunktionen. 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.

[bearbeiten] 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;
}

[bearbeiten] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel

[bearbeiten] Siehe auch

 Bestimmt, ob zwei Elementmengen gleich sind
(Funktionstempelat) [edit]
 Findet das erste Element, das bestimmte Kriterien erfüllt
(Funktionsvorlage) [bearbeiten]
 gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist
(Funktionsvorlage) [bearbeiten]
 Findet die erste Position, an der sich zwei Bereiche unterscheiden
(Funktionsvorlage) [bearbeiten]
 sucht nach einem Bereich von Elementen
(Funktionsvorlage) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/experimental/ranges/algorithm/equal&oldid=157769"