This header is part of the
library.
Includes
(C++20)
support
(C++11)
class template
Classes
(C++23)
adapts two containers to provide a collection of key-value pairs, sorted by unique keys
(class template)
(C++23)
adapts two containers to provide a collection of key-value pairs, sorted by keys
(class template)
std::uses_allocator<std::flat_map>
(C++23)
specializes the
type trait
(class template specialization)
std::uses_allocator<std::flat_multimap>
(C++23)
specializes the
type trait
(class template specialization)
Functions
(C++23)
erases all elements satisfying specific criteria
(function template)
(C++23)
erases all elements satisfying specific criteria
(function template)
Range access
(C++11)(C++14)
returns an iterator to the beginning of a container or array
(function template)
(C++11)(C++14)
returns an iterator to the end of a container or array
(function template)
(C++14)
returns a reverse iterator to the beginning of a container or array
(function template)
(C++14)
returns a reverse end iterator for a container or array
(function template)
(C++17)(C++20)
returns the size of a container or array
(function template)
(C++17)
checks whether the container is empty
(function template)
(C++17)
obtains the pointer to the underlying array
(function template)
Tags
(C++23)
indicates that elements of a range are sorted and unique
(tag)
sorted_equivalentsorted_equivalent_t
(C++23)
indicates that elements of a range are sorted (uniqueness is not required)
(tag)
Synopsis
#include<compare>#include<initializer_list>namespacestd{// class template flat_maptemplate<classKey,classT,classCompare=less<Key>,classKeyContainer=vector<Key>,classMappedContainer=vector<T>>classflat_map;structsorted_unique_t{explicitsorted_unique_t()=default;};inlineconstexprsorted_unique_tsorted_unique{};template<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classAllocator>structuses_allocator<flat_map<Key,T,Compare,KeyContainer,MappedContainer>,Allocator>;// erasure for flat_maptemplate<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classPredicate>constexprtypenameflat_map<Key,T,Compare,KeyContainer,MappedContainer>::size_typeerase_if(flat_map<Key,T,Compare,KeyContainer,MappedContainer>&c,Predicatepred);// class template flat_multimaptemplate<classKey,classT,classCompare=less<Key>,classKeyContainer=vector<Key>,classMappedContainer=vector<T>>classflat_multimap;structsorted_equivalent_t{explicitsorted_equivalent_t()=default;};inlineconstexprsorted_equivalent_tsorted_equivalent{};template<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classAllocator>structuses_allocator<flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>,Allocator>;// erasure for flat_multimaptemplate<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classPredicate>constexprtypenameflat_multimap<Key,T,Compare,KeyContainer,MappedContainer>::size_typeerase_if(flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>&c,Predicatepred);}Class template std::flat_map
namespacestd{template<classKey,classT,classCompare=less<Key>,classKeyContainer=vector<Key>,classMappedContainer=vector<T>>classflat_map{public:// typesusingkey_type=Key;usingmapped_type=T;usingvalue_type=pair<key_type,mapped_type>;usingkey_compare=Compare;usingreference=pair<constkey_type&,mapped_type&>;usingconst_reference=pair<constkey_type&,constmapped_type&>;usingsize_type=size_t;usingdifference_type=ptrdiff_t;usingiterator=/* implementation-defined */;usingconst_iterator=/* implementation-defined */;usingreverse_iterator=std::reverse_iterator<iterator>;usingconst_reverse_iterator=std::reverse_iterator<const_iterator>;usingkey_container_type=KeyContainer;usingmapped_container_type=MappedContainer;classvalue_compare{private:key_compare/*comp*/;// exposition-onlyconstexprvalue_compare(key_comparec):/*comp*/(c){}// exposition-onlypublic:constexprbooloperator()(const_referencex,const_referencey)const{return/*comp*/(x.first,y.first);}};structcontainers{key_container_typekeys;mapped_container_typevalues;};// constructorsconstexprflat_map():flat_map(key_compare()){}constexprflat_map(constflat_map&);constexprflat_map(flat_map&&);constexprflat_map&operator=(constflat_map&);constexprflat_map&operator=(flat_map&&);constexprexplicitflat_map(constkey_compare&comp):/*c*/(),/*compare*/(comp){}constexprflat_map(key_container_typekey_cont,mapped_container_typemapped_cont,constkey_compare&comp=key_compare());constexprflat_map(sorted_unique_t,key_container_typekey_cont,mapped_container_typemapped_cont,constkey_compare&comp=key_compare());template<classInputIter>constexprflat_map(InputIterfirst,InputIterlast,constkey_compare&comp=key_compare()):/*c*/(),/*compare*/(comp){insert(first,last);}template<classInputIter>constexprflat_map(sorted_unique_t,InputIterfirst,InputIterlast,constkey_compare&comp=key_compare()):/*c*/(),/*compare*/(comp){insert(sorted_unique,first,last);}template<container-compatible-range<value_type>R>constexprflat_map(from_range_t,R&&rg):flat_map(from_range,std::forward<R>(rg),key_compare()){}template<container-compatible-range<value_type>R>constexprflat_map(from_range_t,R&&rg,constkey_compare&comp):flat_map(comp){insert_range(std::forward<R>(rg));}constexprflat_map(initializer_list<value_type>il,constkey_compare&comp=key_compare()):flat_map(il.begin(),il.end(),comp){}constexprflat_map(sorted_unique_t,initializer_list<value_type>il,constkey_compare&comp=key_compare()):flat_map(sorted_unique,il.begin(),il.end(),comp){}// constructors with allocatorstemplate<classAlloc>constexprexplicitflat_map(constAlloc&a);template<classAlloc>constexprflat_map(constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_map(constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constAlloc&a);template<classAlloc>constexprflat_map(constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_map(sorted_unique_t,constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constAlloc&a);template<classAlloc>constexprflat_map(sorted_unique_t,constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_map(constflat_map&,constAlloc&a);template<classAlloc>constexprflat_map(flat_map&&,constAlloc&a);template<classInputIter,classAlloc>constexprflat_map(InputIterfirst,InputIterlast,constAlloc&a);template<classInputIter,classAlloc>constexprflat_map(InputIterfirst,InputIterlast,constkey_compare&comp,constAlloc&a);template<classInputIter,classAlloc>constexprflat_map(sorted_unique_t,InputIterfirst,InputIterlast,constAlloc&a);template<classInputIter,classAlloc>constexprflat_map(sorted_unique_t,InputIterfirst,InputIterlast,constkey_compare&comp,constAlloc&a);template<container-compatible-range<value_type>R,classAlloc>constexprflat_map(from_range_t,R&&rg,constAlloc&a);template<container-compatible-range<value_type>R,classAlloc>constexprflat_map(from_range_t,R&&rg,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_map(initializer_list<value_type>il,constAlloc&a);template<classAlloc>constexprflat_map(initializer_list<value_type>il,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_map(sorted_unique_t,initializer_list<value_type>il,constAlloc&a);template<classAlloc>constexprflat_map(sorted_unique_t,initializer_list<value_type>il,constkey_compare&comp,constAlloc&a);constexprflat_map&operator=(initializer_list<value_type>);// iteratorsconstexpriteratorbegin()noexcept;constexprconst_iteratorbegin()constnoexcept;constexpriteratorend()noexcept;constexprconst_iteratorend()constnoexcept;constexprreverse_iteratorrbegin()noexcept;constexprconst_reverse_iteratorrbegin()constnoexcept;constexprreverse_iteratorrend()noexcept;constexprconst_reverse_iteratorrend()constnoexcept;constexprconst_iteratorcbegin()constnoexcept;constexprconst_iteratorcend()constnoexcept;constexprconst_reverse_iteratorcrbegin()constnoexcept;constexprconst_reverse_iteratorcrend()constnoexcept;// capacityconstexprboolempty()constnoexcept;constexprsize_typesize()constnoexcept;constexprsize_typemax_size()constnoexcept;// element accessconstexprmapped_type&operator[](constkey_type&x);constexprmapped_type&operator[](key_type&&x);template<classK>constexprmapped_type&operator[](K&&x);constexprmapped_type&at(constkey_type&x);constexprconstmapped_type&at(constkey_type&x)const;template<classK>constexprmapped_type&at(constK&x);template<classK>constexprconstmapped_type&at(constK&x)const;// modifierstemplate<class...Args>constexprpair<iterator,bool>emplace(Args&&...args);template<class...Args>constexpriteratoremplace_hint(const_iteratorposition,Args&&...args);constexprpair<iterator,bool>insert(constvalue_type&x){returnemplace(x);}constexprpair<iterator,bool>insert(value_type&&x){returnemplace(std::move(x));}constexpriteratorinsert(const_iteratorposition,constvalue_type&x){returnemplace_hint(position,x);}constexpriteratorinsert(const_iteratorposition,value_type&&x){returnemplace_hint(position,std::move(x));}template<classP>constexprpair<iterator,bool>insert(P&&x);template<classP>constexpriteratorinsert(const_iteratorposition,P&&);template<classInputIter>constexprvoidinsert(InputIterfirst,InputIterlast);template<classInputIter>constexprvoidinsert(sorted_unique_t,InputIterfirst,InputIterlast);template<container-compatible-range<value_type>R>constexprvoidinsert_range(R&&rg);template<container-compatible-range<value_type>R>constexprvoidinsert_range(sorted_unique_t,R&&rg);constexprvoidinsert(initializer_list<value_type>il){insert(il.begin(),il.end());}constexprvoidinsert(sorted_unique_t,initializer_list<value_type>il){insert(sorted_unique,il.begin(),il.end());}constexprcontainersextract()&&;constexprvoidreplace(key_container_type&&key_cont,mapped_container_type&&mapped_cont);template<class...Args>constexprpair<iterator,bool>try_emplace(constkey_type&k,Args&&...args);template<class...Args>constexprpair<iterator,bool>try_emplace(key_type&&k,Args&&...args);template<classK,class...Args>constexprpair<iterator,bool>try_emplace(K&&k,Args&&...args);template<class...Args>constexpriteratortry_emplace(const_iteratorhint,constkey_type&k,Args&&...args);template<class...Args>constexpriteratortry_emplace(const_iteratorhint,key_type&&k,Args&&...args);template<classK,class...Args>constexpriteratortry_emplace(const_iteratorhint,K&&k,Args&&...args);template<classM>constexprpair<iterator,bool>insert_or_assign(constkey_type&k,M&&obj);template<classM>constexprpair<iterator,bool>insert_or_assign(key_type&&k,M&&obj);template<classK,classM>constexprpair<iterator,bool>insert_or_assign(K&&k,M&&obj);template<classM>constexpriteratorinsert_or_assign(const_iteratorhint,constkey_type&k,M&&obj);template<classM>constexpriteratorinsert_or_assign(const_iteratorhint,key_type&&k,M&&obj);template<classK,classM>constexpriteratorinsert_or_assign(const_iteratorhint,K&&k,M&&obj);constexpriteratorerase(iteratorposition);constexpriteratorerase(const_iteratorposition);constexprsize_typeerase(constkey_type&x);template<classK>constexprsize_typeerase(K&&x);constexpriteratorerase(const_iteratorfirst,const_iteratorlast);constexprvoidswap(flat_map&y)noexcept(/* see description */);constexprvoidclear()noexcept;// observersconstexprkey_comparekey_comp()const;constexprvalue_comparevalue_comp()const;constexprconstkey_container_type&keys()constnoexcept{return/*c*/.keys;}constexprconstmapped_container_type&values()constnoexcept{return/*c*/.values;}// map operationsconstexpriteratorfind(constkey_type&x);constexprconst_iteratorfind(constkey_type&x)const;template<classK>constexpriteratorfind(constK&x);template<classK>constexprconst_iteratorfind(constK&x)const;constexprsize_typecount(constkey_type&x)const;template<classK>constexprsize_typecount(constK&x)const;constexprboolcontains(constkey_type&x)const;template<classK>constexprboolcontains(constK&x)const;constexpriteratorlower_bound(constkey_type&x);constexprconst_iteratorlower_bound(constkey_type&x)const;template<classK>constexpriteratorlower_bound(constK&x);template<classK>constexprconst_iteratorlower_bound(constK&x)const;constexpriteratorupper_bound(constkey_type&x);constexprconst_iteratorupper_bound(constkey_type&x)const;template<classK>constexpriteratorupper_bound(constK&x);template<classK>constexprconst_iteratorupper_bound(constK&x)const;constexprpair<iterator,iterator>equal_range(constkey_type&x);constexprpair<const_iterator,const_iterator>equal_range(constkey_type&x)const;template<classK>constexprpair<iterator,iterator>equal_range(constK&x);template<classK>constexprpair<const_iterator,const_iterator>equal_range(constK&x)const;friendconstexprbooloperator==(constflat_map&x,constflat_map&y);friendconstexpr/*synth-three-way-result*/<value_type>operator<=>(constflat_map&x,constflat_map&y);friendconstexprvoidswap(flat_map&x,flat_map&y)noexcept(noexcept(x.swap(y))){x.swap(y);}private:containers/*c*/;// exposition-onlykey_compare/*compare*/;// exposition-onlystruct/*key-equiv*/{// exposition-onlyconstexpr/*key-equiv*/(key_comparec):comp(c){}constexprbooloperator()(const_referencex,const_referencey)const{return!comp(x.first,y.first)&&!comp(y.first,x.first);}key_comparecomp;};};template<classKeyContainer,classMappedContainer,classCompare=less<typenameKeyContainer::value_type>>flat_map(KeyContainer,MappedContainer,Compare=Compare())->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classAllocator>flat_map(KeyContainer,MappedContainer,Allocator)->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,less<typenameKeyContainer::value_type>,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare,classAllocator>flat_map(KeyContainer,MappedContainer,Compare,Allocator)->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare=less<typenameKeyContainer::value_type>>flat_map(sorted_unique_t,KeyContainer,MappedContainer,Compare=Compare())->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classAllocator>flat_map(sorted_unique_t,KeyContainer,MappedContainer,Allocator)->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,less<typenameKeyContainer::value_type>,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare,classAllocator>flat_map(sorted_unique_t,KeyContainer,MappedContainer,Compare,Allocator)->flat_map<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classInputIter,classCompare=less</*iter-key-type*/<InputIter>>>flat_map(InputIter,InputIter,Compare=Compare())->flat_map</*iter-key-type*/<InputIter>,/*iter-mapped-type*/<InputIter>,Compare>;template<classInputIter,classCompare=less</*iter-key-type*/<InputIter>>>flat_map(sorted_unique_t,InputIter,InputIter,Compare=Compare())->flat_map</*iter-key-type*/<InputIter>,/*iter-mapped-type*/<InputIter>,Compare>;template<ranges::input_rangeR,classCompare=less</*range-key-type*/<R>>,classAllocator=allocator<byte>>flat_map(from_range_t,R&&,Compare=Compare(),Allocator=Allocator())->flat_map</*range-key-type*/<R>,/*range-mapped-type*/<R>,Compare,vector</*range-key-type*/<R>,/*alloc-rebind*/<Allocator,/*range-key-type*/<R>>>,vector</*range-mapped-type*/<R>,/*alloc-rebind*/<Allocator,/*range-mapped-type*/<R>>>>;template<ranges::input_rangeR,classAllocator>flat_map(from_range_t,R&&,Allocator)->flat_map</*range-key-type*/<R>,/*range-mapped-type*/<R>,less</*range-key-type*/<R>>,vector</*range-key-type*/<R>,/*alloc-rebind*/<Allocator,/*range-key-type*/<R>>>,vector</*range-mapped-type*/<R>,/*alloc-rebind*/<Allocator,/*range-mapped-type*/<R>>>>;template<classKey,classT,classCompare=less<Key>>flat_map(initializer_list<pair<Key,T>>,Compare=Compare())->flat_map<Key,T,Compare>;template<classKey,classT,classCompare=less<Key>>flat_map(sorted_unique_t,initializer_list<pair<Key,T>>,Compare=Compare())->flat_map<Key,T,Compare>;template<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classAllocator>structuses_allocator<flat_map<Key,T,Compare,KeyContainer,MappedContainer>,Allocator>:bool_constant<uses_allocator_v<KeyContainer,Allocator>&&uses_allocator_v<MappedContainer,Allocator>>{};}Class template std::flat_multimap
namespacestd{template<classKey,classT,classCompare=less<Key>,classKeyContainer=vector<Key>,classMappedContainer=vector<T>>classflat_multimap{public:// typesusingkey_type=Key;usingmapped_type=T;usingvalue_type=pair<key_type,mapped_type>;usingkey_compare=Compare;usingreference=pair<constkey_type&,mapped_type&>;usingconst_reference=pair<constkey_type&,constmapped_type&>;usingsize_type=size_t;usingdifference_type=ptrdiff_t;usingiterator=/* implementation-defined */;usingconst_iterator=/* implementation-defined */;usingreverse_iterator=std::reverse_iterator<iterator>;usingconst_reverse_iterator=std::reverse_iterator<const_iterator>;usingkey_container_type=KeyContainer;usingmapped_container_type=MappedContainer;classvalue_compare{private:key_compare/*comp*/;// exposition-onlyconstexprvalue_compare(key_comparec):/*comp*/(c){}// exposition-onlypublic:constexprbooloperator()(const_referencex,const_referencey)const{return/*comp*/(x.first,y.first);}};structcontainers{key_container_typekeys;mapped_container_typevalues;};// constructorsconstexprflat_multimap():flat_multimap(key_compare()){}constexprflat_multimap(constflat_multimap&);constexprflat_multimap(flat_multimap&&);constexprflat_multimap&operator=(constflat_multimap&);constexprflat_multimap&operator=(flat_multimap&&);constexprexplicitflat_multimap(constkey_compare&comp):/*c*/(),/*compare*/(comp){}constexprflat_multimap(key_container_typekey_cont,mapped_container_typemapped_cont,constkey_compare&comp=key_compare());constexprflat_multimap(sorted_equivalent_t,key_container_typekey_cont,mapped_container_typemapped_cont,constkey_compare&comp=key_compare());template<classInputIter>constexprflat_multimap(InputIterfirst,InputIterlast,constkey_compare&comp=key_compare()):/*c*/(),/*compare*/(comp){insert(first,last);}template<classInputIter>constexprflat_multimap(sorted_equivalent_t,InputIterfirst,InputIterlast,constkey_compare&comp=key_compare()):/*c*/(),/*compare*/(comp){insert(sorted_equivalent,first,last);}template<container-compatible-range<value_type>R>constexprflat_multimap(from_range_t,R&&rg):flat_multimap(from_range,std::forward<R>(rg),key_compare()){}template<container-compatible-range<value_type>R>constexprflat_multimap(from_range_t,R&&rg,constkey_compare&comp):flat_multimap(comp){insert_range(std::forward<R>(rg));}constexprflat_multimap(initializer_list<value_type>il,constkey_compare&comp=key_compare()):flat_multimap(il.begin(),il.end(),comp){}constexprflat_multimap(sorted_equivalent_t,initializer_list<value_type>il,constkey_compare&comp=key_compare()):flat_multimap(sorted_equivalent,il.begin(),il.end(),comp){}// constructors with allocatorstemplate<classAlloc>constexprexplicitflat_multimap(constAlloc&a);template<classAlloc>constexprflat_multimap(constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_multimap(constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constAlloc&a);template<classAlloc>constexprflat_multimap(constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_multimap(sorted_equivalent_t,constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constAlloc&a);template<classAlloc>constexprflat_multimap(sorted_equivalent_t,constkey_container_type&key_cont,constmapped_container_type&mapped_cont,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_multimap(constflat_multimap&,constAlloc&a);template<classAlloc>constexprflat_multimap(flat_multimap&&,constAlloc&a);template<classInputIter,classAlloc>constexprflat_multimap(InputIterfirst,InputIterlast,constAlloc&a);template<classInputIter,classAlloc>constexprflat_multimap(InputIterfirst,InputIterlast,constkey_compare&comp,constAlloc&a);template<classInputIter,classAlloc>constexprflat_multimap(sorted_equivalent_t,InputIterfirst,InputIterlast,constAlloc&a);template<classInputIter,classAlloc>constexprflat_multimap(sorted_equivalent_t,InputIterfirst,InputIterlast,constkey_compare&comp,constAlloc&a);template<container-compatible-range<value_type>R,classAlloc>constexprflat_multimap(from_range_t,R&&rg,constAlloc&a);template<container-compatible-range<value_type>R,classAlloc>constexprflat_multimap(from_range_t,R&&rg,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_multimap(initializer_list<value_type>il,constAlloc&a);template<classAlloc>constexprflat_multimap(initializer_list<value_type>il,constkey_compare&comp,constAlloc&a);template<classAlloc>constexprflat_multimap(sorted_equivalent_t,initializer_list<value_type>il,constAlloc&a);template<classAlloc>constexprflat_multimap(sorted_equivalent_t,initializer_list<value_type>il,constkey_compare&comp,constAlloc&a);flat_multimap&operator=(initializer_list<value_type>);// iteratorsconstexpriteratorbegin()noexcept;constexprconst_iteratorbegin()constnoexcept;constexpriteratorend()noexcept;constexprconst_iteratorend()constnoexcept;constexprreverse_iteratorrbegin()noexcept;constexprconst_reverse_iteratorrbegin()constnoexcept;constexprreverse_iteratorrend()noexcept;constexprconst_reverse_iteratorrend()constnoexcept;constexprconst_iteratorcbegin()constnoexcept;constexprconst_iteratorcend()constnoexcept;constexprconst_reverse_iteratorcrbegin()constnoexcept;constexprconst_reverse_iteratorcrend()constnoexcept;// capacityconstexprboolempty()constnoexcept;constexprsize_typesize()constnoexcept;constexprsize_typemax_size()constnoexcept;// modifierstemplate<class...Args>constexpriteratoremplace(Args&&...args);template<class...Args>constexpriteratoremplace_hint(const_iteratorposition,Args&&...args);constexpriteratorinsert(constvalue_type&x){returnemplace(x);}constexpriteratorinsert(value_type&&x){returnemplace(std::move(x));}constexpriteratorinsert(const_iteratorposition,constvalue_type&x){returnemplace_hint(position,x);}constexpriteratorinsert(const_iteratorposition,value_type&&x){returnemplace_hint(position,std::move(x));}template<classP>constexpriteratorinsert(P&&x);template<classP>constexpriteratorinsert(const_iteratorposition,P&&);template<classInputIter>constexprvoidinsert(InputIterfirst,InputIterlast);template<classInputIter>constexprvoidinsert(sorted_equivalent_t,InputIterfirst,InputIterlast);template<container-compatible-range<value_type>R>constexprvoidinsert_range(R&&rg);template<container-compatible-range<value_type>R>constexprvoidinsert_range(sorted_equivalent_t,R&&rg);constexprvoidinsert(initializer_list<value_type>il){insert(il.begin(),il.end());}constexprvoidinsert(sorted_equivalent_t,initializer_list<value_type>il){insert(sorted_equivalent,il.begin(),il.end());}constexprcontainersextract()&&;constexprvoidreplace(key_container_type&&key_cont,mapped_container_type&&mapped_cont);constexpriteratorerase(iteratorposition);constexpriteratorerase(const_iteratorposition);constexprsize_typeerase(constkey_type&x);template<classK>constexprsize_typeerase(K&&x);constexpriteratorerase(const_iteratorfirst,const_iteratorlast);constexprvoidswap(flat_multimap&)noexcept(is_nothrow_swappable_v<key_container_type>&&is_nothrow_swappable_v<mapped_container_type>&&is_nothrow_swappable_v<key_compare>);constexprvoidclear()noexcept;// observersconstexprkey_comparekey_comp()const;constexprvalue_comparevalue_comp()const;constexprconstkey_container_type&keys()constnoexcept{return/*c*/.keys;}constexprconstmapped_container_type&values()constnoexcept{return/*c*/.values;}// map operationsconstexpriteratorfind(constkey_type&x);constexprconst_iteratorfind(constkey_type&x)const;template<classK>constexpriteratorfind(constK&x);template<classK>constexprconst_iteratorfind(constK&x)const;constexprsize_typecount(constkey_type&x)const;template<classK>constexprsize_typecount(constK&x)const;constexprboolcontains(constkey_type&x)const;template<classK>constexprboolcontains(constK&x)const;constexpriteratorlower_bound(constkey_type&x);constexprconst_iteratorlower_bound(constkey_type&x)const;template<classK>constexpriteratorlower_bound(constK&x);template<classK>constexprconst_iteratorlower_bound(constK&x)const;constexpriteratorupper_bound(constkey_type&x);constexprconst_iteratorupper_bound(constkey_type&x)const;template<classK>constexpriteratorupper_bound(constK&x);template<classK>constexprconst_iteratorupper_bound(constK&x)const;constexprpair<iterator,iterator>equal_range(constkey_type&x);constexprpair<const_iterator,const_iterator>equal_range(constkey_type&x)const;template<classK>constexprpair<iterator,iterator>equal_range(constK&x);template<classK>constexprpair<const_iterator,const_iterator>equal_range(constK&x)const;friendconstexprbooloperator==(constflat_multimap&x,constflat_multimap&y);friendconstexpr/*synth-three-way-result*/<value_type>operator<=>(constflat_multimap&x,constflat_multimap&y);friendconstexprvoidswap(flat_multimap&x,flat_multimap&y)noexcept(noexcept(x.swap(y))){x.swap(y);}private:containers/*c*/;// exposition-onlykey_compare/*compare*/;// exposition-only};template<classKeyContainer,classMappedContainer,classCompare=less<typenameKeyContainer::value_type>>flat_multimap(KeyContainer,MappedContainer,Compare=Compare())->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classAllocator>flat_multimap(KeyContainer,MappedContainer,Allocator)->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,less<typenameKeyContainer::value_type>,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare,classAllocator>flat_multimap(KeyContainer,MappedContainer,Compare,Allocator)->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare=less<typenameKeyContainer::value_type>>flat_multimap(sorted_equivalent_t,KeyContainer,MappedContainer,Compare=Compare())->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classAllocator>flat_multimap(sorted_equivalent_t,KeyContainer,MappedContainer,Allocator)->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,less<typenameKeyContainer::value_type>,KeyContainer,MappedContainer>;template<classKeyContainer,classMappedContainer,classCompare,classAllocator>flat_multimap(sorted_equivalent_t,KeyContainer,MappedContainer,Compare,Allocator)->flat_multimap<typenameKeyContainer::value_type,typenameMappedContainer::value_type,Compare,KeyContainer,MappedContainer>;template<classInputIter,classCompare=less</*iter-key-type*/<InputIter>>>flat_multimap(InputIter,InputIter,Compare=Compare())->flat_multimap</*iter-key-type*/<InputIter>,/*iter-mapped-type*/<InputIter>,Compare>;template<classInputIter,classCompare=less</*iter-key-type*/<InputIter>>>flat_multimap(sorted_equivalent_t,InputIter,InputIter,Compare=Compare())->flat_multimap</*iter-key-type*/<InputIter>,/*iter-mapped-type*/<InputIter>,Compare>;template<ranges::input_rangeR,classCompare=less</*range-key-type*/<R>>,classAllocator=allocator<byte>>flat_multimap(from_range_t,R&&,Compare=Compare(),Allocator=Allocator())->flat_multimap</*range-key-type*/<R>,/*range-mapped-type*/<R>,Compare,vector</*range-key-type*/<R>,/*alloc-rebind*/<Allocator,/*range-key-type*/<R>>>,vector</*range-mapped-type*/<R>,/*alloc-rebind*/<Allocator,/*range-mapped-type*/<R>>>>;template<ranges::input_rangeR,classAllocator>flat_multimap(from_range_t,R&&,Allocator)->flat_multimap</*range-key-type*/<R>,/*range-mapped-type*/<R>,less</*range-key-type*/<R>>,vector</*range-key-type*/<R>,/*alloc-rebind*/<Allocator,/*range-key-type*/<R>>>,vector</*range-mapped-type*/<R>,/*alloc-rebind*/<Allocator,/*range-mapped-type*/<R>>>>;template<classKey,classT,classCompare=less<Key>>flat_multimap(initializer_list<pair<Key,T>>,Compare=Compare())->flat_multimap<Key,T,Compare>;template<classKey,classT,classCompare=less<Key>>flat_multimap(sorted_equivalent_t,initializer_list<pair<Key,T>>,Compare=Compare())->flat_multimap<Key,T,Compare>;template<classKey,classT,classCompare,classKeyContainer,classMappedContainer,classAllocator>structuses_allocator<flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>,Allocator>:bool_constant<uses_allocator_v<KeyContainer,Allocator>&&uses_allocator_v<MappedContainer,Allocator>>{};}References
C++23 standard (ISO/IEC 14882:2024):
24.6.4 Header <flat_map> synopsis [flat.map.syn]
24.6.9.2 Definition [flat.map.defn]
24.6.10.2 Definition [flat.multimap.defn]