Ableitungs-Guides für std::flat_set

 

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::flat_set

Membertypen

Memberfunktionen

flat_set::flat_set flat_set::operator= Iteratoren flat_set::beginflat_set::cbegin flat_set::endflat_set::cend flat_set::rbeginflat_set::crbegin flat_set::rendflat_set::crend Kapazität flat_set::size flat_set::max_size flat_set::empty Observer flat_set::key_comp flat_set::value_comp      Modifizierer flat_set::clear flat_set::insert flat_set::insert_range flat_set::emplace flat_set::emplace_hint flat_set::erase flat_set::swap flat_set::extract flat_set::replace Suche flat_set::count flat_set::find flat_set::contains flat_set::equal_range flat_set::lower_bound flat_set::upper_bound Nicht-Member-Funktionen operator==operator<=> swap(std::flat_set) erase_if(std::flat_set)

Hilfsklassen

uses_allocator<std::flat_set>

Tags

sorted_unique      sorted_unique_t

Deduction Guides

 

Definiert in Header <flat_set>
template< class KeyContainer,           class Compare = std::less<typename KeyContainer::value_type> > flat_set( KeyContainer, Compare = Compare() )     -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;	(1)	(seit C++23)
template< class KeyContainer, class Allocator > flat_set( KeyContainer, Allocator )     -> flat_set<typename KeyContainer::value_type,                 std::less<typename KeyContainer::value_type>, KeyContainer>;	(2)	(seit C++23)
template< class KeyContainer, class Compare, class Allocator > flat_set( KeyContainer, Compare, Allocator )     -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;	(3)	(seit C++23)
template< class KeyContainer,           class Compare = std::less<typename KeyContainer::value_type> > flat_set( std::sorted_unique_t, KeyContainer, Compare = Compare() )     -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;	(4)	(seit C++23)
template< class KeyContainer, class Allocator > flat_set( std::sorted_unique_t, KeyContainer, Allocator )     -> flat_set<typename KeyContainer::value_type,                 std::less<typename KeyContainer::value_type>, KeyContainer>;	(5)	(seit C++23)
template< class KeyContainer, class Compare, class Allocator > flat_set( std::sorted_unique_t, KeyContainer, Compare, Allocator )     -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;	(6)	(seit C++23)
template< class InputIter,           class Compare = std::less</*iter-value-type*/<InputIter>> > flat_set( InputIter, InputIter, Compare = Compare() )     -> flat_set</*iter-value-type*/<InputIter>, Compare>;	(7)	(seit C++23)
template< class InputIter,           class Compare = std::less</*iter-value-type*/<InputIter>> > flat_set( std::sorted_unique_t, InputIter, InputIter, Compare = Compare() )     -> flat_set</*iter-value-type*/<InputIter>, Compare>;	(8)	(seit C++23)
template< ranges::input_range R,           class Compare = std::less<ranges::range_value_t<R>>,           class Allocator = std::allocator<ranges::range_value_t<R>> > flat_set( std::from_range_t, R&&, Compare = Compare(), Allocator = Allocator() )     -> flat_set<ranges::range_value_t<R>, Compare,                 std::vector<ranges::range_value_t<R>,                 /*alloc-rebind*/<Allocator, ranges::range_value_t<R>>>>;	(9)	(seit C++23)
template< ranges::input_range R, class Allocator > flat_set( std::from_range_t, R&&, Allocator )     -> flat_set<ranges::range_value_t<R>, std::less<ranges::range_value_t<R>>,                 std::vector<ranges::range_value_t<R>,                 /*alloc-rebind*/<Allocator, ranges::range_value_t<R>>>>;	(10)	(seit C++23)
template< class Key, class Compare = std::less<Key> > flat_set( std::initializer_list<Key>, Compare = Compare() )     -> flat_set<Key, Compare>;	(11)	(seit C++23)
template< class Key, class Compare = std::less<Key> > flat_set( std::sorted_unique_t,                std::initializer_list<Key>, Compare = Compare() )     -> flat_set<Key, Compare>;	(12)	(seit C++23)

Diese Ableitungs-Guides werden für bereitgestellt, um die Ableitung von Folgendem zu ermöglichen:

1) Ein Container und ein Komparator.

2) Ein Container und ein Allokator.

3) Ein Container, ein Komparator und ein Allokator.

4) Das Tag std::sorted_unique_t, ein Container und ein Komparator.

5) Das Tag std::sorted_unique_t, ein Container und ein Allokator.

6) Das Tag std::sorted_unique_t, ein Container, ein Komparator und ein Allokator.

7) Ein Iterator-Bereich und ein Komparator.

8) Das Tag std::sorted_unique_t, ein Iterator-Bereich und ein Komparator.

9) Das Tag std::from_range_t, ein input_range, ein Komparator und ein Allokator.

10) Das Tag std::from_range_t, ein input_range und ein Allokator.

11) Die std::initializer_list und ein Komparator.

12) Das Tag std::sorted_unique_t, die std::initializer_list und ein Komparator.

Diese Überladungen nehmen an der Überladungsauflösung teil, nur wenn InputIt LegacyInputIterator erfüllt, Alloc Allocator erfüllt und Comp Allocator nicht erfüllt.

Hinweis: Das Ausmaß, in dem die Bibliothek bestimmt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, mit Ausnahme dessen, dass ganzzahlige Typen als Eingabeiteratoren nicht qualifiziert sind. Ebenso ist das Ausmaß, in dem bestimmt wird, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, mit Ausnahme dessen, dass als Minimum der Mitgliedstyp Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) gut geformt sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.