std::forward_list<T,Allocator>::merge

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::forward_list

Memberfunktionen
forward_list::forward_list forward_list::~forward_list forward_list::operator= forward_list::assign forward_list::assign_range (C++23)   forward_list::get_allocator Elementzugriff forward_list::front Iteratoren forward_list::before_beginforward_list::cbefore_begin forward_list::beginforward_list::cbegin forward_list::endforward_list::cend Kapazität forward_list::empty forward_list::max_size	Modifizierer forward_list::clear forward_list::emplace_front forward_list::push_front forward_list::insert_after forward_list::emplace_after forward_list::erase_after forward_list::insert_range_after (C++23) forward_list::prepend_range (C++23) forward_list::pop_front forward_list::resize forward_list::swap Operationen forward_list::merge forward_list::splice_after forward_list::removeforward_list::remove_if forward_list::reverse forward_list::unique forward_list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::forward_list) erase(std::forward_list)erase_if(std::forward_list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides (C++17)

 

void merge( forward_list& other );	(1)	(seit C++11)
void merge( forward_list&& other );	(2)	(seit C++11)
template< class Compare > void merge( forward_list& other, Compare comp );	(3)	(seit C++11)
template< class Compare > void merge( forward_list&& other, Compare comp );	(4)	(seit C++11)

Die Funktion tut nichts, wenn other auf dasselbe Objekt verweist wie *this.

Andernfalls wird other in *this integriert. Beide Listen sollten sortiert sein. Es werden keine Elemente kopiert, und der Container other wird nach dem Zusammenführen leer. Diese Operation ist stabil: Für äquivalente Elemente in den beiden Listen gehen die Elemente aus *this den Elementen aus other immer voraus, und die Reihenfolge äquivalenter Elemente von *this und other ändert sich nicht.

Keine Iteratoren oder Referenzen werden ungültig. Die Zeiger und Referenzen auf die verschobenen Elemente aus *this sowie die auf diese Elemente verweisenden Iteratoren verweisen weiterhin auf dieselben Elemente von *this anstelle von other.

1,2) Elemente werden mit std::less<T>()(bis C++14)std::less<>()(seit C++14) verglichen.

3,4) Elemente werden mit comp verglichen.

Wenn *this oder other in Bezug auf den entsprechenden Komparator nicht sortiert ist, oder get_allocator() != other.get_allocator(), ist das Verhalten undefiniert.

Parameter

Sonstiges	-	ein weiterer Container, der zusammengeführt werden soll
comp	-	Vergleichsfunktions-Objekt (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), das ​true zurückgibt, wenn das erste Argument *weniger* (d.h. *vorher*) als das zweite geordnet ist. Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgendem sein bool cmp(const Type1& a, const Type2& b); Obwohl die Signatur nicht unbedingt const& haben muss, darf die Funktion die übergebenen Objekte nicht verändern und muss in der Lage sein, alle Werte vom Typ (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie zu akzeptieren (daher ist Type1& nicht erlaubt, ebenso wenig Type1, es sei denn, für Type1 ist ein Move äquivalent zu einem Kopieren(since C++11)). Die Typen Type1 und Type2 müssen so sein, dass ein Objekt vom Typ forward_list<T, Allocator>::const_iterator dereferenziert und dann implizit in beide konvertiert werden kann. ​
Typanforderungen
- Compare muss die Anforderungen an Compare erfüllen.

Rückgabewert

(keine)

Ausnahmen

Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, haben diese Funktionen keine Auswirkung (starke Ausnahme-Sicherheitsgarantie). Außer wenn die Ausnahme von einem Vergleich herrührt.

Komplexität

Wenn other auf dasselbe Objekt verweist wie *this, werden keine Vergleiche durchgeführt.

Andernfalls, gegeben \(\scriptsize N\)N als std::distance(begin(), end()) und \(\scriptsize R\)R als std::distance(other.begin(), other.end())

1,2) Höchstens \(\scriptsize N+R-1\)N+R-1 Vergleiche mit operator<.

3,4) Höchstens \(\scriptsize N+R-1\)N+R-1 Aufrufe der Vergleichsfunktion comp.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <forward_list>
 
std::ostream& operator<<(std::ostream& ostr, const std::forward_list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
 
int main()
{
    std::forward_list<int> list1 = {5, 9, 1, 3, 3};
    std::forward_list<int> list2 = {8, 7, 2, 3, 4, 4};
 
    list1.sort();
    list2.sort();
    std::cout << "list1: " << list1 << '\n';
    std::cout << "list2: " << list2 << '\n';
 
    list1.merge(list2);
    std::cout << "merged:" << list1 << '\n';
}

Ausgabe

list1:  1 3 3 5 9
list2:  2 3 4 4 7 8
merged: 1 2 3 3 3 4 4 5 7 8 9

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2045	C++11	O(1) Knotenverschiebung konnte nicht garantiert werden, wenn get_allocator() != other.get_allocator()	Das Verhalten ist in diesem Fall nicht definiert.
LWG 3088	C++11	die Auswirkung, wenn *this und other auf dasselbe Objekt verweisen, war nicht spezifiziert operator< könnte für Zeigerelemente fehlschlagen	als No-Op spezifiziert implementierungsdefiniert strikte totale Ordnung verwendet

Siehe auch

splice_after	verschiebt Elemente aus einem anderen forward_list (öffentliche Memberfunktion)
merge	Führt zwei sortierte Bereiche zusammen (Funktionstemplate)
inplace_merge	Führt zwei sortierte Bereiche an Ort und Stelle zusammen (Funktionstemplate)
ranges::merge (C++20)	Führt zwei sortierte Bereiche zusammen (Algorithmus-Funktionsobjekt)
ranges::inplace_merge (C++20)	Führt zwei sortierte Bereiche an Ort und Stelle zusammen (Algorithmus-Funktionsobjekt)