Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute unverändert bleiben müssen und die Zelleninhalte leer sind. Daher bleibt die Ausgabe identisch mit der Eingabe.)
flat_set ( )
: flat_set ( key_compare ( ) ) { }
(1) (seit C++23)
template < class Allocator >
flat_set ( const flat_set & other, const Allocator & alloc ) ;
(2) (seit C++23)
template < class Allocator >
flat_set ( flat_set && other, const Allocator & alloc ) ;
(3) (seit C++23)
explicit flat_set ( container_type cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (seit C++23)
template < class Allocator >
flat_set ( const container_type & cont, const Allocator & alloc ) ;
(5) (seit C++23)
template < class Allocator >

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

const Allocator & alloc ) ;
(6) (seit C++23)
flat_set ( std:: sorted_unique_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_set ( std:: sorted_unique_t s, const container_type & cont,

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

flat_set ( std:: sorted_unique_t s, const container_type & cont,

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

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

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

flat_set ( InputIter first, InputIter last,

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

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

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

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

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

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

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

flat_set ( std:: sorted_unique_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_set ( std:: sorted_unique_t s, InputIter first, InputIter last,

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

flat_set ( std:: sorted_unique_t s, InputIter first, InputIter last,

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

const key_compare & comp = key_compare ( ) )

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

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

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

const key_compare & comp = key_compare ( ) )

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

flat_set ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

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

flat_set ( std:: sorted_unique_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 . Macht schließlich Elemente eindeutig, d.h. löscht alle bis auf das erste Element aus jeder Gruppe aufeinanderfolgender äquivalenter Elemente.
5) Gleich wie (4) , entspricht flat_set ( cont ) ; . Siehe Allokator-Verwendungshinweis unten.
6) Gleich wie (4) , entspricht flat_set ( cont, comp ) ; . Siehe allocator usage note 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_set ( s, cont ) ; . Siehe Allokator-Verwendungshinweis unten.
9) Gleich wie (7) , entspricht flat_set ( 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 ) , äquivalent 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 wie durch insert_range ( std:: forward < R > ( rg ) ) ; .
17) Gleich wie (16) unter Verwendung als delegating constructor .
18,19) Gleich wie (16) . Siehe allocator usage note 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-Konstruktor . Konstruiert den zugrundeliegenden Container mit den Inhalten der Initialisierungsliste init , wobei (13) als Delegating-Konstruktor verwendet wird.
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.

Note for overloads (4-6,13-19,23-25) : If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844 ).

Inhaltsverzeichnis

Hinweis zur Allocator-Verwendung

Die Konstruktoren (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) entsprechen 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 weiterer flat_set , der 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 den Quell- Bereich der zu kopierenden Elemente definiert
init - eine Initialisierungsliste zur Initialisierung der Elemente des zugrundeliegenden Containers
rg - ein container-kompatibler Bereich (d.h. ein input_range , dessen Elemente in value_type konvertierbar sind) als Quelle zur Initialisierung des zugrundeliegenden Containers
fr - ein Unterscheidungs-Tag , das anzeigt, dass das enthaltene Element bereichskonstruiert werden soll
s - ein Unterscheidungs-Tag , das anzeigt, dass die Eingabesequenz bezüglich compare sortiert ist und alle ihre Elemente eindeutig sind
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 wenn cont bezüglich compare sortiert ist, andernfalls 𝓞(N·log(N)) , wobei N der Wert von cont. size ( ) vor diesem Aufruf ist.
7-9) Entspricht dem entsprechenden Move-Konstruktor des umschlossenen Containers, d.h. konstant oder linear in der Größe von cont .
10-12) Konstant.
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 if the input range rg is sorted with respect to compare , otherwise 𝓞(N·log(N)) , where N is the value of cont. size ( ) before this call.
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 .

Exceptions

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) zu 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)