Namespaces
Variants

deduction guides for std::map

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Défini dans l'en-tête <map>
template < class InputIt,

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

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

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

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

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

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

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

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

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

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

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

map std:: less < /*range-key-t*/ < R >> , Alloc > ;
(6) (depuis C++23)
Alias de types d'aide uniquement d'exposition
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( exposition uniquement* )
template < class InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( exposition uniquement* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( exposition uniquement* )
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 >>> ;
( exposition uniquement* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(depuis C++23)
( exposition uniquement* )
template < ranges:: input_range Range >

using /*type-mappé-de-plage*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(depuis C++23)
( exposition uniquement* )
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 > ;
(depuis C++23)
( exposition uniquement* )
1-4) Ces guides de déduction sont fournis pour map afin de permettre la déduction à partir d'une plage d'itérateurs (surcharges (1,3) ) et std::initializer_list (surcharges (2,4) ).
5,6) Ces guides de déduction sont fournis pour map afin de permettre la déduction à partir d'un tag std::from_range_t et d'un input_range .

Ces surcharges participent à la résolution de surcharge seulement si InputIt satisfait LegacyInputIterator , Alloc satisfait Allocator , et Comp ne satisfait pas Allocator .

Note : la mesure dans laquelle la bibliothèque détermine qu'un type ne satisfait pas LegacyInputIterator n'est pas spécifiée, sauf qu'au minimum les types entiers ne sont pas qualifiés comme itérateurs d'entrée. De même, la mesure dans laquelle elle détermine qu'un type ne satisfait pas Allocator n'est pas spécifiée, sauf qu'au minimum le type membre Alloc::value_type doit exister et l'expression std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) doit être bien formée lorsqu'elle est traitée comme un opérande non évalué.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharge ( 5,6 )

Exemple

Exécuter ce code 
#include <map>
int main()
{
    // std::map m1 = {{"foo", 1}, {"bar", 2}};
        // Erreur : la liste d'initialisation entre accolades n'a pas de type ;
        // impossible de déduire pair<Key, T> à partir de {"foo", 1} ou {"bar", 2}
    std::map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
    std::map m2(m1.begin(), m1.end()); // guide #1
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement publié Comportement corrigé
LWG 3025 C++17 les guides d'initialisation ( 2,4 ) prennent std:: pair < const Key, T > utilisent std:: pair < Key, T >