std::multimap<Key,T,Compare,Allocator>::multimap

See More

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::multimap

Funciones miembro

multimap::multimap multimap::~multimap        multimap::operator= multimap::get_allocator

Iteradores multimap::beginmultimap::cbegin (C++11) multimap::endmultimap::cend (C++11) multimap::rbeginmultimap::crbegin (C++11)    multimap::rendmultimap::crend (C++11) Capacidad multimap::size multimap::max_size multimap::empty Observadores multimap::key_comp multimap::value_comp Modificadores multimap::clear multimap::insert multimap::erase multimap::swap multimap::merge (C++17) multimap::insert_range (C++23) multimap::emplace (C++11) multimap::emplace_hint (C++11) multimap::extract (C++17) Búsqueda multimap::count multimap::find multimap::contains (C++20) multimap::equal_range multimap::lower_bound multimap::upper_bound

Funciones no miembro

operator==operator<=> (C++20) std::swap(std::multimap) erase_if(std::multimap) (C++20)   operator!=operator<operator>operator<=operator>= (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)

Guías de deducción(C++17)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

multimap(); explicit multimap( const Compare& comp, {{#pad:|17}} const Allocator& alloc = Allocator() );	(1)
explicit multimap( const Allocator& alloc );	(1)	(desde C++11)
	(2)
template< class InputIt > multimap( InputIt first, InputIt last, {{#pad:|8}} const Compare& comp = Compare(), {{#pad:|8}} const Allocator& alloc = Allocator() );
template< class InputIt > multimap( InputIt first, InputIt last, {{#pad:|8}} const Allocator& alloc );			(desde C++14)
multimap( const multimap& other );		(3)
multimap( const multimap& other, const Allocator& alloc );		(3)	(desde C++11)
multimap( multimap&& other );		(4)	(desde C++11)
multimap( multimap&& other, const Allocator& alloc );		(4)	(desde C++11)
		(5)
multimap( std::initializer_list<value_type> init, {{#pad:|8}} const Compare& comp = Compare(), {{#pad:|8}} const Allocator& alloc = Allocator() );				(desde C++11)
multimap( std::initializer_list<value_type> init, {{#pad:|8}} const Allocator& );				(desde C++14)

Construye un nuevo contenedor a partir de una variedad de fuentes de datos y, opcionalmente, utiliza el asignador de memoria alloc proporcionado por el usuario o el objeto función de comparación comp.

1) Construye un contenedor vacío.

2) Construye el contenedor con el contenido del rango [first, last).

3) Constructor de copia. Construye el contenedor con la copia del contenido de other.

Si alloc no se proporciona, el asignador se obtiene llamando a std::allocator_traits<allocator_type>::select_on_container_copy_construction( other.get_allocator()).	(desde C++11)
El parámetro de plantilla Allocator solo se deduce del primer argumento mientras se usa en la deducción de argumentos de plantillas de clase.	(desde C++23)

4) Constructor de movimiento. Construye el contenedor con el contenido de other utilizando la semántica de movimiento. Si alloc no se proporciona, el asignador se obtiene mediante la construcción por movimiento a partir del asignador que pertenece a other.

El parámetro de plantilla Allocator solo se deduce del primer argumento mientras se usa en la deducción de argumentos de plantillas de clase.

(desde C++23)

5) Construye el contenedor con el contenido de la lista de inicializadores init.

Parámetros

alloc	-	El asignador a usar para todas las asignaciones de memoria de este contenedor.
comp	-	El objeto función de comparación a usar para todas las comparaciones de claves.
first, last	-	El rango del cual copiar los elementos.
other	-	Otro contenedor a usar como fuente con el cual inicializar los elementos del contenedor.
init	-	La lista de inicializadores con la cual inicializar los elementos del contenedor.
Requisitos de tipo
- InputIt debe satisfacer los requisitos de InputIterator.
- Compare debe satisfacer los requisitos de Compare.
- Allocator debe satisfacer los requisitos de Allocator.

Complejidad

1) Constante.

2) N log(N) donde N = std::distance(first, last) por lo general, lineal en N si el rango ya está ordenado por value_comp().

3) Lineal en el tamaño de other.

4) Constante. Si se da alloc y alloc != other.get_allocator(), entonces lineal.

5) N log(N) donde N = init.size() por lo general, lineal en N si init ya está ordenada por value_comp().

Excepciones

Las llamadas a Allocator::allocate pueden lanzar.

Notas

Después de la construcción por movimiento de un contenedor (la sobrecarga (4)), las referencias, punteros e iteradores (aparte del iterador al final) a other permanecen válidos, pero se refieren a los elementos que ahora se encuentran en *this. El estándar actual da esta garantía vía la generalización en [container.requirements.general]/12, y una garantía más directa está bajo consideración vía LWG 2321.

Aunque no se requiere formalmente hasta C++23, algunas implementaciones ya han puesto el parámetro de plantilla Allocator en contextos no deducidos en modalidades anteriores.

Ejemplo

Ejecuta este código

#include <iostream>
#include <map>
 
struct Punto { double x, y; };
struct CompDePuntos { // comparador de tipos Punto
    bool operator()(const Punto& lhs, const Punto& rhs) const { 
        return lhs.x < rhs.x; // NB. ignora y a propósito
    }
};
 
int main() {
    std::multimap<int, int> m = {{1,1},{2,2},{3,3},{4,4},{5,5},{4,4},{3,3},{2,2},{1,1}};
    for(auto& p: m) std::cout << p.first << ' ' << p.second << '\n';

    // comparación personalizada
    std::multimap<Punto, double, CompDePuntos> mag{
        { {5, 12}, 13 },
        { {3, 4}, 5 },
        { {8, 15}, 17 },
        { {3, -3}, -1 },
    };

  for(auto p : mag)
      std::cout << "La magnitud de (" << p.first.x
                << ", " << p.first.y << ") es "
                << p.second << '\n';
}

Salida:

1 1
1 1
2 2
2 2
3 3
3 3
4 4
4 4
5 5
La magnitud de (3, 4) es 5
La magnitud de (3, -3) es -1
La magnitud de (5, 12) es 13
La magnitud de (8, 15) es 17

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2193	C++11	El constructor por defecto es explicit.	Se hizo no explicit.

Véase también

operator=

Asigna valores al contenedor. (función miembro pública)