Vergleichen Sie zwei aufeinanderfolgende Elemente in std :: list

Question

Ich würde gerne zwei aufeinanderfolgende Elemente in einer std :: list vergleichen, während ich durch die Liste iteriere. Was ist der richtige Weg, um auf Element i + 1 zuzugreifen, während sich mein Iterator auf Element i befindet? Dank Cobe

Answer 1

-Boost hat ein Dienstprogramm next (und seine Umkehrung, prior) genannt für genau diesen Zweck.

*itr == *next(itr) 

Edit: Aber wenn wir einen Schritt zurück in den Wald zu sehen, die echte Frage ist, warum benutzerdefinierte schreiben Sie Ihre adjacent_find Funktion? (Ich empfehle die Antwort von Nicola Bonelli zu akzeptieren.) Das ist Teil der STL, und erfordert nicht Boost, wenn Ihr Code Boost nicht verwendet (dank der Kommentatoren für das Aufzeigen).

Answer 2

Der einfachste Weg wäre, zwei Iteratoren zu halten (da Sie sowieso beim vorletzten stoppen müssen).

std::list<int>::const_iterator second = list.begin(), 
           end = list.end(); 

if (second != end) // Treat empty list 
    for(std::list<int>::const_iterator first = second++; // Post-increment 
     second != end; 
     ++first, ++second) 
    { 
     //... 
    } 

anzumerken, dass mit dem firstpost-incrementation von second so initialisiert wird, wenn die Schleife beginnt firstlist.begin() ist und die zweite ist list.begin()+1.

Chris Jester-Young points out die next und prior Funktionen steigern kann, auch wenn ich mit diesen Funktionen nicht vertraut bin (für meine Sünden) deren Umsetzung ist trivial (besonders wenn man bedenkt, dass list bidirektionale Iteratoren hat).

template <class Iterator> 
Iterator next(Iterator i) // Call by value, original is not changed 
{ 
    return ++i; 
} 
// Implementing prior is left as an exercise to the reader ;o) 

Mein Gefühl ist, dass die Verwendung von next dieses Problem nicht Suite sowie die beiden Iteratoren beibehalten, da Sie sich daran erinnern müssen, um sicherzustellen, next(i) nicht gleich end() bei jedem Gebrauch.

---

Edits:

• Fehler behoben, wenn die Liste leer dank Luc Touraille ‚s Kommentar.
• Hinzufügen Verweis auf next und warum ich denke, es passt nicht zu diesem Anwendungsfall.

Answer 3

STL stellt den boundary_find() - Algorithmus zur Verfügung, mit dem zwei aufeinanderfolgende gleiche Elemente gefunden werden können. Es gibt auch eine Version mit einem benutzerdefinierten Prädikat.

Dies sind die Prototypen:

template <class ForwardIterator> 
    ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last); 

template <class ForwardIterator, class BinaryPredicate> 
    ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, 
            BinaryPredicate pred); 

Answer 4

Liste ist ein Wende Container, so seine Iteratoren Bidirektionale Iteratoren sind, die ein Modell der Vorwärts Iterator ist, die ich ziemlich sicher bin, bedeutet, dass Sie dies tun können (oder etwas Gleichwertiges, wenn Sie das Ausbrechen aus der Mitte einer Schleife usw. allergisch sind):

if (!l.empty()) { 
    for (list<T>::const_iterator i = l.begin();;) { 
     const T &a = *i; 
     ++i; 
     if (i == l.end()) break; 
     do_comparison(a, *i); 
    } 
} 

Sie konnten das nicht tun, mit einem InputIterator, denn mit denen die Werte nur „existieren“, so lange wie Sie einen Iterator bei ihnen haben. Aber Sie können mit einem Forward Iterator.

Answer 5

for (list<int>::iterator it = test.begin(); it!=test.end(); it++) { 
     cout<<*it<<":\t"; 
     list<int>::iterator copy = it; 
     for(list<int>::iterator it2 = ++copy; it2!=test.end();it2++){ 
      cout<<*it2<<"\t"; 
     } 
     cout<<endl; 
    }