std::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::list

Memberfunktionen
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator Elementzugriff list::front list::back Iteratoren list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) Kapazität list::size list::empty list::max_size	Modifizierer list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap Operationen list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::list) erase(std::list)erase_if(std::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)
Deduktionshilfen(C++17)

 

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

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

Andernfalls werden die Elemente von other in *this zusammengeführt. Beide Listen sollten sortiert sein. Es werden keine Elemente kopiert, und der Container other wird nach dem Zusammenführen leer. Diese Operation ist stabil: Bei äquivalenten Elementen in den beiden Listen gehen die Elemente aus *this immer den Elementen aus other 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 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 sind, 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 beschaffen sein, dass ein Objekt vom Typ 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 Garantien für die Ausnahmesicherheit). Es sei denn, die Ausnahme stammt von einem Vergleich.

Komplexität

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

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

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 <list>
 
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
 
int main()
{
    std::list<int> list1 = {5, 9, 1, 3, 3};
    std::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 300	C++98	die Auswirkung, wenn *this und other sich auf dasselbe Objekt beziehen, wurde nicht spezifiziert	als No-Op spezifiziert
LWG 1207	C++98	war unklar, ob Iteratoren und/oder Referenzen ungültig werden	gültig bleiben
LWG 1215	C++98	O(1) Knotenverschiebungen konnten nicht garantiert werden, wenn get_allocator() != other.get_allocator()	Das Verhalten ist in diesem Fall nicht definiert.
LWG 3088	C++98	operator< sich bei Zeigerelementen falsch verhalten konnte	implementierungsdefiniert strikte totale Ordnung verwendet

Siehe auch

splice	verschiebt Elemente aus einer anderen 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)