Namespaces
Variants

deduction guides for std::multimap

From cppreference.net

C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
Definido en el encabezado <map>
template < class InputIt,

class Comp = std:: less < /*iter-key-t*/ < InputIt >> ,
class Alloc = std:: allocator < /*iter-to-alloc-t*/ < InputIt >> >
multimap ( InputIt, InputIt, Comp = Comp ( ) , Alloc = Alloc ( ) )

- > multimap < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > , Comp, Alloc > ;
(1) (desde C++17)
template < class Key,

class T,
class Comp = std:: less < Key > ,
class Alloc = std:: allocator < std:: pair < const Key, T >> >
multimap ( std:: initializer_list < std:: pair < Key, T >> , Comp = Comp ( ) , Alloc = Alloc ( ) )

- > multimap < Key, T, Comp, Alloc > ;
(2) (desde C++17)
template < class InputIt, class Alloc >

multimap ( InputIt, InputIt, Alloc )
- > multimap < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,

std:: less < /*iter-key-t*/ < InputIt >> , Alloc > ;
(3) (desde C++17)
template < class Key, class T, class Alloc >

multimap ( std:: initializer_list < std:: pair < Key, T >> , Alloc )

- > multimap < Key, T, std:: less < Key > , Alloc > ;
(4) (desde C++17)
template < ranges:: input_range R, class Compare = std:: less < /*range-key-t*/ < R > ,

class Alloc = std:: allocator < /*range-to-alloc-t*/ < R >> >
multimap ( std:: from_range_t , R && , Compare = Compare ( ) , Alloc = Alloc ( ) )

- > multimap < /*range-key-t*/ < R > , range_mapped_t < R > , Compare, Alloc > ;
(5) (desde C++23)
template < ranges:: input_range R, class Alloc >

multimap ( std:: from_range_t , R && , Alloc )
- > multimap < /*range-key-t*/ < R > , range_mapped_t < R > ,

multimap std:: less < /*range-key-t*/ < R >> , Alloc > ;
(6) (desde C++23)
Alias de tipos auxiliares solo para exposición
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( solo para exposición* )
template < class InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( solo para exposición* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( solo para exposición* )
template < class InputIt >

using /*iter-to-alloc-t*/ =
std:: pair < std:: add_const_t < tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ,

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >>> ;
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(desde C++23)
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(desde C++23)
( solo para exposición* )
template < ranges:: input_range Range >

using /*range-to-alloc-t*/ =
std:: pair < std:: add_const_t < typename ranges:: range_value_t < Range > :: first_type > ,

typename ranges:: range_value_t < Range > :: second_type > ;
(desde C++23)
( solo para exposición* )
1-4) Estas guías de deducción se proporcionan para multimap para permitir la deducción desde un rango de iteradores (sobrecargas (1,3) ) y std::initializer_list (sobrecargas (2,4) ).
5,6) Estas guías de deducción se proporcionan para multimap para permitir la deducción a partir de una etiqueta std::from_range_t y un input_range .

Estas sobrecargas participan en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator , Alloc satisface Allocator , y Comp no satisface Allocator .

Nota: el grado en que la biblioteca determina que un tipo no satisface LegacyInputIterator no está especificado, excepto que como mínimo los tipos integrales no califican como iteradores de entrada. Del mismo modo, el grado en que determina que un tipo no satisface Allocator no está especificado, excepto que como mínimo el tipo miembro Alloc::value_type debe existir y la expresión std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) debe estar bien formada cuando se trata como un operando no evaluado.

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción conscientes de rangos; sobrecarga ( 5,6 )

Ejemplo

Ejecutar este código 
#include <map>
int main()
{
    // std::multimap m1 = {{"foo", 1}, {"bar", 2}};
        // Error: la lista de inicialización entre llaves no tiene tipo; no se puede deducir
        // pair<Key, T> de {"foo", 1} o {"bar", 2}
    std::multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guía #2
    std::multimap m2(m1.begin(), m1.end()); // guía #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 3025 C++17 las guías de lista de inicialización ( 2,4 ) toman std:: pair < const Key, T > usar std:: pair < Key, T >