std::flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>::insert_range

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

node-handle (C++17)

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::flat_multimap

Member types

Member functions

flat_multimap::flat_multimap    flat_multimap::operator= Modifiers flat_multimap::clear flat_multimap::erase flat_multimap::swap flat_multimap::extract flat_multimap::replace flat_multimap::insert flat_multimap::insert_range flat_multimap::emplace flat_multimap::emplace_hint Lookup flat_multimap::count flat_multimap::find flat_multimap::contains flat_multimap::equal_range flat_multimap::lower_bound flat_multimap::upper_bound Iterators flat_multimap::beginflat_multimap::cbegin flat_multimap::endflat_multimap::cend flat_multimap::rbeginflat_multimap::crbegin flat_multimap::rendflat_multimap::crend Capacity flat_multimap::size flat_multimap::max_size flat_multimap::empty Observers flat_multimap::key_comp flat_multimap::keys flat_multimap::value_comp flat_multimap::values

Non-member functions

swap(std::flat_multimap) erase_if(std::flat_multimap)     operator==operator<=>

Helper classes

uses_allocator<std::flat_multimap>

Tags

sorted_equivalent          sorted_equivalent_t

Deduction guides

 

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

Inserts a copy of each element in the range rg into underlying containers c as if by:

for(constauto& e : rg){ c.keys.insert(c.keys.end(), e.first); c.values.insert(c.values.end(), e.second);}

Then, sorts the range of newly inserted elements with respect to value_comp(). Merges the resulting sorted range and the sorted range of pre-existing elements into a single sorted range.

Each iterator in the range rg is dereferenced exactly once. The behavior is undefined if rg overlaps with the container.

Parameters

rg

-

a container compatible range, that is, an input_range whose elements are convertible to T

Return value

(none)

Complexity

N + M·log(M), where N is size() before the operation and M is ranges::distance(rg).

Notes

Since insert_range performs an in-place merge operation, that may allocate memory.

Example

Run this code

#include <iostream>#include <flat_map>#include <utility>   void println(auto, autoconst& container){for(constauto&[key, value]: container)std::cout<<'{'<< key <<','<< value <<'}'<<' ';std::cout<<'\n';}   int main(){auto container =std::flat_multimap{std::pair{1, 11}, {3, 33}, {2, 22}, {4, 44}};constauto 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);}

Output:

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

See also

insert

inserts elements (public member function)