Namespaces
Variants

std::flat_multiset<Key,Compare,KeyContainer>:: flat_multiset

From cppreference.net

C++
Containers library
std::flat_multiset
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
flat_multiset ( )
: flat_multiset ( key_compare ( ) ) { }
(1) (seit C++23)
template < class Allocator >
flat_multiset ( const flat_multiset & other, const Allocator & alloc ) ;
(2) (seit C++23)
template < class Allocator >
flat_multiset ( flat_multiset && other, const Allocator & alloc ) ;
(3) (seit C++23)
explicit flat_multiset ( container_type cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (seit C++23)
template < class Allocator >
flat_multiset ( const container_type & cont, const Allocator & alloc ) ;
(5) (seit C++23)
template < class Allocator >

flat_multiset ( const container_type & cont, const key_compare & comp,

const Allocator & alloc ) ;
(6) (seit C++23)
flat_multiset ( std:: sorted_equivalent_t s, container_type cont,

const key_compare & comp = key_compare ( ) )

: c ( std :: move ( cont ) ) , compare ( comp ) { }
(7) (seit C++23)
template < class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, const container_type & cont,

const Allocator & alloc ) ;
(8) (seit C++23)
template < class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, const container_type & cont,

const key_compare & comp, const Allocator & alloc ) ;
(9) (seit C++23)
explicit flat_multiset ( const key_compare & comp )
: c ( ) , compare ( comp ) { }
(10) (seit C++23)
template < class Allocator >
flat_multiset ( const key_compare & comp, const Allocator & alloc ) ;
(11) (seit C++23)
template < class Allocator >
explicit flat_multiset ( const Allocator & alloc ) ;
(12) (seit C++23)
template < class InputIter >

flat_multiset ( InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(13) (seit C++23)
template < class InputIter, class Allocator >

flat_multiset ( InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(14) (seit C++23)
template < class InputIter, class Allocator >
flat_multiset ( InputIter first, InputIter last, const Allocator & alloc ) ;
(15) (seit C++23)
template < container-compatible-range < value_type > R >

flat_multiset ( std:: from_range_t , R && rg, const key_compare & comp )

: flat_multiset ( comp ) ;
(16) (seit C++23)
template < container-compatible-range < value_type > R >

flat_multiset ( std:: from_range_t fr, R && rg )

: flat_multiset ( fr, std:: forward < R > ( rg ) , key_compare ( ) ) { }
(17) (seit C++23)
template < container-compatible-range < value_type > R, class Allocator >
flat_multiset ( std:: from_range_t , R && rg, const Allocator & alloc ) ;
(18) (seit C++23)
template < container-compatible-range < value_type > R, class Allocator >

flat_multiset ( std:: from_range_t , R && rg, const key_compare & comp,

const Allocator & alloc ) ;
(19) (seit C++23)
template < class InputIter >

flat_multiset ( std:: sorted_equivalent_t s, InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( first, last ) , compare ( comp ) { }
(20) (seit C++23)
template < class InputIter, class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(21) (seit C++23)
template < class InputIter, class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, InputIter first, InputIter last,

const Allocator & alloc ) ;
(22) (seit C++23)
flat_multiset ( std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_multiset ( init. begin ( ) , init. end ( ) , comp ) { }
(23) (seit C++23)
template < class Allocator >

flat_multiset ( std:: initializer_list < value_type > init, const key_compare & comp,

const Allocator & alloc ) ;
(24) (seit C++23)
template < class Allocator >
flat_multiset ( std:: initializer_list < value_type > init, const Allocator & alloc ) ;
(25) (seit C++23)
flat_multiset ( std:: sorted_equivalent_t s, std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_multiset ( s, init. begin ( ) , init. end ( ) , comp ) { }
(26) (seit C++23)
template < class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, std:: initializer_list < value_type > init,

const key_compare & comp, const Allocator & alloc ) ;
(27) (seit C++23)
template < class Allocator >

flat_multiset ( std:: sorted_equivalent_t s, std:: initializer_list < value_type > init,

const Allocator & alloc ) ;
(28) (seit C++23)

Konstruiert einen neuen Container-Adapter aus verschiedenen Datenquellen und optional bereitgestelltem Vergleichsfunktionsobjekt comp und/oder Allokator alloc .

1) Ein Standardkonstruktor. Konstruiert einen leeren Container-Adapter.
2) Ein copy constructor . Konstruiert c mit der Kopie der Inhalte von other. c und compare mit other. compare . Siehe allocator usage note unten.
3) Ein move constructor . Konstruiert den Container-Adapter mit den Inhalten von other unter Verwendung von Move-Semantik. Siehe allocator usage note unten.
4) Konstruiert den zugrundeliegenden Container mit dem Inhalt des Containers cont . Initialisiert zuerst c mit std :: move ( cont ) und compare mit comp . Sortiert anschließend c bezüglich comp .
5) Gleich wie (4) , entspricht flat_multiset ( cont ) ; . Siehe Allokator-Verwendungshinweis unten.
6) Gleich wie (4) , entspricht flat_multiset ( cont, comp ) ; . Siehe Allokator-Verwendungshinweis unten.
7) Konstruiert den zugrundeliegenden Container mit dem Inhalt des anderen Containers cont . Initialisiert c mit std :: move ( cont ) und compare mit comp .
8) Gleich wie (7) , entspricht flat_multiset ( s, cont ) ; . Siehe Allokator-Verwendungshinweis unten.
9) Gleich wie (7) , entspricht flat_multiset ( s, cont, comp ) ; . Siehe Allokator-Verwendungshinweis unten.
10) Konstruiert einen leeren Container-Adapter.
11,12) Konstruiert einen leeren Container-Adapter. Siehe allocator usage note unten.
13) Konstruiert den Container-Adapter mit den Inhalten des Bereichs [ first , last ) , was äquivalent ist zu insert ( first, last ) ; .
14,15) Gleich wie (13) . Siehe allocator usage note unten.
16) Konstruiert den Container-Adapter mit den Inhalten des Bereichs rg . Zuerst wird (10) als delegating constructor verwendet. Dann initialisiert c mit den Inhalten von rg als ob durch insert_range ( std:: forward < R > ( rg ) ) ; .
17) Gleich wie (16) , verwendet als delegating constructor .
18,19) Gleich wie (16) . Siehe Allokator-Hinweis unten.
20) Konstruiert den zugrundeliegenden Container mit dem Inhalt des Bereichs [ first , last ) . Initialisiert c mit c ( first, last ) und compare mit compare ( comp ) .
21,22) Gleich wie (20) . Siehe Allokator-Verwendungshinweis unten.
23) Ein initializer-list constructor . Konstruiert den zugrundeliegenden Container mit den Inhalten der Initialisierungsliste init , unter Verwendung von (13) als delegating constructor .
24,25) Gleich wie (23) . Siehe allocator usage note unten.
26) Ein Initializer-List-Konstruktor . Konstruiert den zugrundeliegenden Container mit den Inhalten der Initialisierungsliste init , wobei (20) als Delegierender Konstruktor verwendet wird.
27,28) Speichern als (26) . Siehe allocator usage note unten.

Hinweis für Überladungen (13-15,20-22) : Wenn [ first , last ) kein gültiger Bereich ist, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Hinweise zur Allocator-Verwendung

Die Konstruktoren (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) sind äquivalent zu den entsprechenden Nicht-Allokator-Konstruktoren, außer dass c mit Uses-Allocator-Konstruktion erstellt wird. Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn std:: uses_allocator_v < container_type, Allocator > true ist.

Parameter

cont - ein Container, der als Quelle zur Initialisierung des zugrundeliegenden Containers verwendet wird
other - ein weiteres flat_multiset , das als Quelle zur Initialisierung der Elemente des zugrundeliegenden Containers verwendet wird
alloc - ein Allokator, der für alle Speicherallokationen des zugrundeliegenden Containers verwendet wird
comp - ein Funktionsobjekt, das für alle Schlüsselvergleiche verwendet wird
first, last - das Iteratorpaar, das die Quell- Range der zu kopierenden Elemente definiert
init - eine Initialisierungsliste zur Initialisierung der Elemente des zugrundeliegenden Containers
rg - eine container-kompatible Range (d.h. eine input_range , deren Elemente in value_type konvertierbar sind) als Quelle zur Initialisierung des zugrundeliegenden Containers
fr - ein Unterscheidungs-Tag , das anzeigt, dass das enthaltene Element per Range-Konstruktor erstellt werden soll
s - ein Unterscheidungs-Tag , das anzeigt, dass die Eingabesequenz bezüglich compare sortiert ist
Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
Compare muss die Anforderungen von Compare erfüllen.
-
Allocator muss die Anforderungen von Allocator erfüllen.

Komplexität

1) Konstante.
2) Linear in der Größe von other .
3) Gleich wie der entsprechende Move-Konstruktor des umschlossenen Containers, d.h. konstant oder linear in der Größe von cont .
4-6) Linear in N if cont is sorted with respect to compare , otherwise 𝓞(N·log(N)) , where N is the value of cont. size ( ) before this call.
7-9) Gleich wie der entsprechende Move-Konstruktor des umschlossenen Containers, d.h. konstant oder linear in der Größe von cont .
10-12) Konstante.
13-15) Linear in N wenn der Eingabebereich [ first , last ) bezüglich compare sortiert ist, andernfalls 𝓞(N·log(N)) , wobei N der Wert von cont. size ( ) vor diesem Aufruf ist.
16-19) Linear in N wenn der Eingabebereich rg bezüglich compare sortiert ist, andernfalls 𝓞(N·log(N)) , wobei N der Wert von cont. size ( ) vor diesem Aufruf ist.
20-22) Linear in der Größe von [ first , last ) .
23-25) Linear in N if the elements of init are sorted with respect to compare , otherwise 𝓞(N·log(N)) , where N is the value of cont. size ( ) before this call.
26-28) Linear in der Größe von init .

Ausnahmen

Aufrufe von Allocator::allocate können eine Ausnahme auslösen.

Hinweise

Nach Container-Verschiebekonstruktion (Überladung ( 3 ) ) bleiben Referenzen, Zeiger und Iteratoren (außer dem End-Iterator) auf other gültig, verweisen jedoch auf Elemente, die sich nun in * this befinden. Der aktuelle Standard gibt diese Garantie über die pauschale Aussage in [container.reqmts]/67 , und eine direktere Garantie wird via LWG issue 2321 geprüft.

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Siehe auch

weist Werte dem Container-Adapter zu
(öffentliche Elementfunktion)