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

 

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

 

std::pair<iterator, bool> insert( const value_type& value );	(1)	(seit C++23)
std::pair<iterator, bool> insert( value_type&& value );	(2)	(seit C++23)
iterator insert( const_iterator pos, const value_type& value );	(3)	(seit C++23)
iterator insert( const_iterator pos, value_type&& value );	(4)	(seit C++23)
template< class K > iterator insert( const_iterator pos, K&& x );	(5)	(seit C++23)
template< class InputIt > void einfügen( InputIt first, InputIt last );	(6)	(seit C++23)
template< class K > std::pair<iterator, bool> insert( K&& x );	(7)	(seit C++23)
template< class InputIt > void insert( std::sorted_unique_t, InputIt first, InputIt last );	(8)	(seit C++23)
void insert( std::initializer_list<key_type> ilist );	(9)	(seit C++23)
void insert( std::sorted_unique_t s, std::initializer_list<key_type> ilist );	(10)	(seit C++23)

Fügt Element(e) in den Container ein, falls der Container noch kein Element mit einem äquivalenten Schlüssel enthält.

1) Fügt value ein. Äquivalent zu return emplace(value);.

2) Fügt value ein. Äquivalent zu return emplace(std::move(value));.

3) Fügt value an einer Position ein, die so nah wie möglich an der Position direkt vor pos liegt. Äquivalent zu return emplace_hint(pos, value);.

4) Fügt value an einer Position ein, die so nah wie möglich an der Position direkt vor pos liegt. Äquivalent zu return emplace_hint(pos, std::move(value));.

5,7) Wenn *this bereits ein Element enthält, das transparent äquivalent zu x vergleichbar ist, geschieht nichts. Andernfalls wird ein neues Element eingefügt, als ob durch

• (5) emplace(pos, std::forward<K>(x)) (an einer Position, die so nah wie möglich an der Position direkt vor pos liegt);
• (7) emplace(std::forward<K>(x)).

Die Konvertierung von x in key_type muss ein Objekt u konstruieren, für das find(k) == find(u) true ist. Andernfalls ist das Verhalten undefiniert.

Diese Überladungen nehmen nur an der Overload-Auflösung teil, wenn

• Der qualifizierte Bezeichner Compare::is_transparent gültig ist und einen Typ bezeichnet, und
• std::is_constructible_v<value_type, K> true ist,

was zusammen ermöglicht, diese Funktion aufzurufen, ohne eine Instanz von Key zu konstruieren.

6) Äquivalent zur Sequenz von Operationen

1. Fügt Elemente aus dem Bereich [first, last) ein, als ob durch c.insert(c.end(), first, last);.
2. Sortiert den Bereich der neu eingefügten Elemente in Bezug auf compare.
3. Vereinigt den resultierenden sortierten Bereich und den sortierten Bereich der bereits vorhandenen Elemente zu einem einzigen sortierten Bereich. (Hinweis: Die Vereinigungsoperation kann Speicher allokieren).
4. Entfernt alle, bis auf das erste Element jeder Gruppe von aufeinanderfolgenden äquivalenten Elementen.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent vergleichbar sind, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

8) Fügt Elemente aus dem Bereich [first, last) ein. Äquivalent zu insert(first, last);.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent vergleichbar sind, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

9) Fügt Elemente aus der Initialisierungsliste ilist ein. Äquivalent zu insert(ilist.begin(), ilist.end());.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent vergleichbar sind, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

10) Fügt Elemente aus der Initialisierungsliste ilist ein. Äquivalent zu insert(s, ilist.begin(), ilist.end());.

Wenn mehrere Elemente im Bereich Schlüssel haben, die äquivalent vergleichbar sind, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

Parameter

pos	-	Iterator zu der Position, vor der das neue Element eingefügt wird
value	-	Elementwert, der eingefügt werden soll
first, last	-	das Iteratorenpaar, das den Quell- Bereich der einzufügenden Elemente definiert
ilist	-	Initialisierungsliste, aus der die Werte eingefügt werden sollen
x	-	ein Wert eines beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann
s	-	ein Disambiguierungstag, der angibt, dass die Eingabesequenz sortiert ist (in Bezug auf compare) und nur eindeutige Elemente enthält
Typanforderungen
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

Rückgabewert

1,2) Ein Paar, das aus einem Iterator auf das eingefügte Element (oder auf das Element, das die Einfügung verhindert hat) und einem bool-Wert besteht, der auf true gesetzt ist, wenn und nur wenn die Einfügung stattgefunden hat.

3-5) Ein Iterator zum eingefügten Element oder zum Element, das die Einfügung verhindert hat.

6) (keiner)

7) Ein Paar, bestehend aus einem Iterator zum eingefügten Element (oder zum Element, das die Einfügung verhindert hat) und einem bool-Wert, der auf true gesetzt wird, wenn und nur wenn die Einfügung stattgefunden hat.

8-10) (keiner)

Ausnahmen

1-5,7) Wenn durch eine Operation eine Ausnahme ausgelöst wird, hat die Einfügung keine Auswirkung.

Komplexität

1-5) Linear in size().

6) N + M·log(M), wobei N die size() vor der Operation und M std::distance(first, last) ist.

7) Linear in size().

8) Linear in N, wobei N die size() nach der Operation ist.

9) N + M·log(M), wobei N die size() vor der Operation und M ilist.size() ist.

10) Linear in N, wobei N die size() nach der Operation ist.

Hinweise

Die "hinted insert" (3-5) gibt kein bool zurück, um mit der Positions-Einfügung bei sequenziellen Containern, wie std::vector::insert, kompatibel zu sein. Dies ermöglicht die Erstellung von generischen Einfügern wie std::inserter. Eine Möglichkeit, den Erfolg einer "hinted insert" zu überprüfen, ist der Vergleich von size() vor und nach der Operation.

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <flat_set>
#include <iostream>
 
int main()
{
    std::flat_set<int> set;
 
    auto result_1 = set.insert(3);
    assert(result_1.first != set.end()); // it is a valid iterator
    assert(*result_1.first == 3);
    if (result_1.second)
        std::cout << "insert done\n";
 
    auto result_2 = set.insert(3);
    assert(result_2.first == result_1.first); // the same iterator
    assert(*result_2.first == 3);
    if (!result_2.second)
        std::cout << "no insertion\n";
}

Ausgabe

insert done
no insertion

Siehe auch

emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
inserter	erstellt einen std::insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)