std::map<Key,T,Compare,Allocator>::insert_range

 

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

Memberfunktionen

map::map map::~map               map::operator= map::get_allocator

Elementzugriff map::at map::operator[] Iteratoren map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Kapazität map::size map::max_size map::empty Observer map::key_comp map::value_comp Modifizierer map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Suche map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Leitfaden zur Ableitung (C++17)

 

template< container-compatible-range<value_type> R > void insert_range( R&& rg );		(seit C++23)

Fügt eine Kopie jedes Elements im Bereich rg ein, genau dann, wenn kein Element mit einem Schlüssel, der dem Schlüssel dieses Elements in *this entspricht, vorhanden ist.

Jeder Iterator im Bereich rg wird genau einmal dereferenziert. Das Verhalten ist undefiniert, wenn rg mit dem Container überlappt.

Keine Iteratoren oder Referenzen werden ungültig.

Parameter

rg	-	Ein Container-kompatibler Bereich, d. h. ein input_range, dessen Elemente in T konvertierbar sind
Typanforderungen
- value_type muss aus *ranges::begin(rg) in map EmplaceConstructible sein. Andernfalls ist das Verhalten undefiniert.

Rückgabewert

(keine)

Komplexität

N·log(a.size() + N), wobei N ranges::distance(rg) ist.

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Ranges-kompatible Konstruktion und Einfügung

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <map>
#include <utility>
 
void println(auto, auto const& container)
{
    for (const auto& [key, value] : container)
        std::cout << '{' << key << ',' << value << '}' << ' ';
    std::cout << '\n';
}
 
int main()
{
    auto container = std::map{std::pair{1, 11}, {3, 33}, {2, 22}, {4, 44}};
    const auto rg = {std::pair{-1, -11}, {3, -33}, {-2, -22}};
#ifdef __cpp_lib_containers_ranges
    container.insert_range(rg);
#else
    container.insert(rg.begin(), rg.end());
#endif
    println("{}", container);
}

Ausgabe

{-2,-22} {-1,-11} {1,11} {2,22} {3,33} {4,44}

Siehe auch

insert

fügt Elemente ein oder Knoten(seit C++17) (public member function)