std::multimap<Key,T,Compare,Allocator>:: insert
From cppreference.net
|
iterator insert
(
const
value_type
&
value
)
;
|
(1) | |
|
iterator insert
(
value_type
&&
value
)
;
|
(2) | (desde C++17) |
|
template
<
class
P
>
iterator insert ( P && value ) ; |
(3) | (desde C++11) |
| (4) | ||
|
iterator insert
(
iterator pos,
const
value_type
&
value
)
;
|
(hasta C++11) | |
|
iterator insert
(
const_iterator pos,
const
value_type
&
value
)
;
|
(desde C++11) | |
|
iterator insert
(
const_iterator pos, value_type
&&
value
)
;
|
(5) | (desde C++17) |
|
template
<
class
P
>
iterator insert ( const_iterator pos, P && value ) ; |
(6) | (desde C++11) |
|
template
<
class
InputIt
>
void insert ( InputIt first, InputIt last ) ; |
(7) | |
|
void
insert
(
std::
initializer_list
<
value_type
>
ilist
)
;
|
(8) | (desde C++11) |
|
iterator insert
(
node_type
&&
nh
)
;
|
(9) | (desde C++17) |
|
iterator insert
(
const_iterator pos, node_type
&&
nh
)
;
|
(10) | (desde C++17) |
Inserta elemento(s) en el contenedor.
1-3)
Inserta
value
. Si el contenedor tiene elementos con clave equivalente, inserta en el límite superior de ese rango.
La sobrecarga
(3)
es equivalente a
emplace
(
std::
forward
<
P
>
(
value
)
)
y solo participa en la resolución de sobrecarga si
std::
is_constructible
<
value_type, P
&&
>
::
value
==
true
.
4-6)
Inserta
value
en la posición más cercana posible a la posición inmediatamente anterior a
pos
.
La sobrecarga
(6)
es equivalente a
emplace_hint
(
hint,
std::
forward
<
P
>
(
value
)
)
y solo participa en la resolución de sobrecarga si
std::
is_constructible
<
value_type, P
&&
>
::
value
==
true
.
7)
Inserta elementos del rango
[
first
,
last
)
.
8)
Inserta elementos desde la lista de inicialización
ilist
.
9)
Si
nh
es un
node handle
vacío, no hace nada. De lo contrario, inserta el elemento poseído por
nh
en el contenedor y devuelve un iterador que apunta al elemento insertado. Si existe un rango que contiene elementos con claves equivalentes a
nh.
key
(
)
en el contenedor, el elemento se inserta al final de ese rango. El comportamiento es indefinido si
nh
no está vacío y
get_allocator
(
)
!
=
nh.
get_allocator
(
)
.
10)
Si
nh
es un
node handle
vacío, no hace nada y retorna el iterador final. En caso contrario, inserta el elemento poseído por
nh
en el contenedor, y retorna el iterador que apunta al elemento con clave equivalente a
nh.
key
(
)
. El elemento se inserta tan cerca como sea posible de la posición inmediatamente anterior a
pos
. El comportamiento es indefinido si
nh
no está vacío y
get_allocator
(
)
!
=
nh.
get_allocator
(
)
.
No se invalidan iteradores ni referencias. Si la inserción es exitosa, se invalidan los punteros y referencias al elemento obtenidos mientras se mantiene en el node handle, y los punteros y referencias obtenidos para ese elemento antes de ser extraído se vuelven válidos. (desde C++17)
Contenidos |
Parámetros
| pos | - | iterador a la posición antes de la cual se insertará el nuevo elemento |
| value | - | valor del elemento a insertar |
| first, last | - | el par de iteradores que define el rango fuente de elementos a insertar |
| ilist | - | lista de inicializadores de la cual insertar los valores |
| nh | - | un manejador de nodo compatible |
| Requisitos de tipo | ||
-
InputIt
debe cumplir con los requisitos de
LegacyInputIterator
.
|
||
Valor de retorno
1-6)
Un iterador al elemento insertado.
7,8)
(ninguno)
9,10)
Iterador final si
nh
estaba vacío, iterador que apunta al elemento insertado en caso contrario.
Excepciones
1-6)
Si se lanza una excepción por cualquier operación, la inserción no tiene efecto.
7,8)
No hay garantía de seguridad de excepciones.
9,10)
Si se lanza una excepción por cualquier operación, la inserción no tiene efecto.
Complejidad
1-3)
O(log(size()))
4-6)
Constante amortizado si la inserción ocurre en la posición inmediatamente anterior a
pos
,
O(log(size()))
en caso contrario.
7,8)
O(N·log(size() + N))
, donde
N
es el número de elementos a insertar.
9)
O(log(size()))
10)
Constante amortizado si la inserción ocurre en la posición justo antes de
pos
,
O(log(size()))
en caso contrario.
Ejemplo
Ejecutar este código
#include <functional> #include <iostream> #include <map> #include <string> #include <string_view> #include <utility> template<class M> void print(const std::string_view rem, const M& mmap) { std::cout << rem << ' '; for (const auto& e : mmap) std::cout << '{' << e.first << ',' << e.second << "} "; std::cout << '\n'; } int main() { // inicialización por lista std::multimap<int, std::string, std::greater<int>> mmap {{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}}; print("#1", mmap); // inserción usando value_type mmap.insert(decltype(mmap)::value_type(5, "pqr")); print("#2", mmap); // inserción usando pair mmap.insert(std::pair{6, "uvw"}); print("#3", mmap); mmap.insert({7, "xyz"}); print("#4", mmap); // inserción usando initializer_list mmap.insert({{5, "one"}, {5, "two"}}); print("#5", mmap); // inserción usando un par de iteradores mmap.clear(); const auto il = {std::pair{1, "ä"}, {2, "ё"}, {2, "ö"}, {3, "ü"}}; mmap.insert(il.begin(), il.end()); print("#6", mmap); }
Salida:
#1 {5,def} {3,baz} {2,foo} {2,bar} {1,abc}
#2 {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#3 {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#4 {7,xyz} {6,uvw} {5,def} {5,pqr} {3,baz} {2,foo} {2,bar} {1,abc}
#5 {7,xyz} {6,uvw} {5,def} {5,pqr} {5,one} {5,two} {3,baz} {2,foo} {2,bar} {1,abc}
#6 {3,ü} {2,ё} {2,ö} {1,ä}
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 233 | C++98 | pos era solo una sugerencia, podía ser ignorada completamente |
se requiere que la inserción sea
lo más cercana posible a la posición justo antes de pos |
| LWG 264 | C++98 |
la complejidad de la sobrecarga
(5)
se requería que fuera lineal si
el rango
[
first
,
last
)
está ordenado según
Compare
|
eliminó el requisito lineal
en este caso especial |
| LWG 371 | C++98 |
el orden de elementos equivalentes
no estaba garantizado que se preservara |
se requiere que se preserve |
| LWG 2005 | C++11 | las sobrecargas (3,6) estaban pobremente descritas | mejoró la descripción |
Véase también
|
(C++11)
|
construye elementos en el lugar
(función miembro pública) |
|
(C++11)
|
construye elementos en el lugar usando una pista
(función miembro pública) |
|
crea un
std::insert_iterator
del tipo inferido del argumento
(plantilla de función) |