Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: flat_map

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
flat_map ( )
: flat_map ( key_compare ( ) ) { }
(1) (C++23부터)
template < class Allocator >
flat_map ( const flat_map & , const Allocator & alloc ) ;
(2) (C++23부터)
template < class Allocator >
flat_map ( flat_map && , const Allocator & alloc ) ;
(3) (C++23 이후)
flat_map ( key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare & comp = key_compare ( ) ) ;
(4) (C++23부터)
template < class Allocator >

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const Allocator & alloc ) ;
(5) (C++23 이후)
template < class Allocator >

flat_map ( const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const key_compare & comp, const Allocator & alloc ) ;
(6) (C++23 이후)
flat_map ( std:: sorted_unique_t , key_container_type key_cont,

mapped_container_type mapped_cont,

const key_compare & comp = key_compare ( ) ) ;
(7) (C++23 이후)
template < class Allocator >

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,

const mapped_container_type & mapped_cont, const Allocator & alloc ) ;
(8) (C++23 이후)
template < class Allocator >

flat_map ( std:: sorted_unique_t , const key_container_type & key_cont,
const mapped_container_type & mapped_cont,

const key_compare & comp, const Allocator & alloc ) ;
(9) (C++23부터)
explicit flat_map ( const key_compare & comp )
: c ( ) , compare ( comp ) { }
(10) (C++23 이후)
template < class Allocator >
flat_map ( const key_compare & comp, const Allocator & alloc ) ;
(11) (C++23 이후)
template < class Allocator >
explicit flat_map ( const Allocator & alloc ) ;
(12) (C++23 이후)
template < class InputIter >

flat_map ( InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(13) (C++23 이후)
template < class InputIter, class Allocator >

flat_map ( InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(14) (C++23 이후)
template < class InputIter, class Allocator >
flat_map ( InputIter first, InputIter last, const Allocator & alloc ) ;
(15) (C++23 이후)
template < container-compatible-range < value_type > R >

flat_map ( std:: from_range_t , R && rg, const key_compare & comp )

: flat_map ( comp ) ;
(16) (C++23부터)
template < container-compatible-range < value_type > R >

flat_map ( std:: from_range_t fr, R && rg )

: flat_map ( fr, std:: forward < R > ( rg ) , key_compare ( ) ) { }
(17) (C++23 이후)
template < container-compatible-range < value_type > R, class Allocator >
flat_map ( std:: from_range_t , R && rg, const Allocator & alloc ) ;
(18) (C++23부터)
template < container-compatible-range < value_type > R, class Allocator >

flat_map ( std:: from_range_t , R && rg, const key_compare & comp,

const Allocator & alloc ) ;
(19) (C++23 이후)
template < class InputIter >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,
const key_compare & comp = key_compare ( ) )

: c ( ) , compare ( comp ) ;
(20) (C++23 이후)
template < class InputIter, class Allocator >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,

const key_compare & comp, const Allocator & alloc ) ;
(21) (C++23 이후)
template < class InputIter, class Allocator >

flat_map ( std:: sorted_unique_t s, InputIter first, InputIter last,

const Allocator & alloc ) ;
(22) (C++23 이후)
flat_map ( std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_map ( init. begin ( ) , init. end ( ) , comp ) { }
(23) (C++23 이후)
template < class Allocator >

flat_map ( std:: initializer_list < value_type > init, const key_compare & comp,

const Allocator & alloc ) ;
(24) (C++23부터)
template < class Allocator >
flat_map ( std:: initializer_list < value_type > init, const Allocator & alloc ) ;
(25) (C++23 이후)
flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp = key_compare ( ) )

: flat_map ( s, init. begin ( ) , init. end ( ) , comp ) { }
(26) (C++23 이후)
template < class Allocator >

flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const key_compare & comp, const Allocator & alloc ) ;
(27) (C++23 이후)
template < class Allocator >

flat_map ( std:: sorted_unique_t s, std:: initializer_list < value_type > init,

const Allocator & alloc ) ;
(28) (C++23부터)

다양한 데이터 소스로부터 새로운 컨테이너 어댑터를 구성하며, 선택적으로 사용자 제공 비교 함수 객체 comp 및/또는 할당자 alloc 를 사용합니다.

1) 기본 생성자. 빈 컨테이너 어댑터를 생성합니다.
2) 복사 생성자 . c 를 other. c 의 내용 사본으로 구성하고, compare 를 other. compare 로 구성합니다. 아래의 할당자 사용 참고 를 참조하십시오.
3) move constructor . 컨테이너 어댑터를 other 의 내용을 이동 의미론을 사용하여 구성합니다. 아래의 allocator usage note 를 참조하십시오.
4) 먼저 c.keys 를 std :: move ( key_cont ) 로, c.values 를 std :: move ( mapped_cont ) 로, compare 를 comp 로 초기화합니다. 그런 다음 기본 범위 [ begin ( ) , end ( ) ) 를 value_comp() 에 따라 정렬합니다. 마지막으로 다음과 같이 중복 요소들을 제거합니다:
auto zv = views:: zip ( c. keys , c. values ) ;
auto it = ranges:: unique ( zv, key_equiv ( compare ) ) . begin ( ) ;
auto dist = distance ( zv. begin ( ) , it ) ;
c. keys . erase ( c. keys . begin ( ) + dist, c. keys . end ( ) ) ;
c. values . erase ( c. values . begin ( ) + dist, c. values . end ( ) ) ; .
5) (4) 와 동일하며, flat_map ( key_cont, mapped_cont ) ; 와 동등합니다. 아래의 allocator 사용 참고 를 참조하십시오.
6) (4) 와 동일하며, 다음에 해당합니다: flat_map ( key_cont, mapped_cont, comp ) ; . 아래의 allocator 사용 참고 사항 을 참조하십시오.
7) c.keys 를 std :: move ( key_cont ) 로, c.values 를 std :: move ( mapped_cont ) 로, compare 를 comp 로 초기화합니다.
8) (7) 과 동일하며, flat_map ( s, key_cont, mapped_cont ) ; 와 동등합니다. 아래의 allocator 사용법 참고 를 확인하십시오.
9) (7) 와 동일하며, 다음 코드와 동등합니다: flat_map ( s, key_cont, mapped_cont, comp ) ; . 아래의 allocator 사용 참고 사항 을 참조하십시오.
10) 빈 컨테이너 어댑터를 생성합니다.
11,12) 빈 컨테이너 어댑터를 생성합니다. 아래의 allocator usage note 를 참조하십시오.
13) 컨테이너 어댑터를 범위 [ first , last ) 의 내용으로 생성하며, 이는 insert ( first, last ) ; 와 동등합니다.
14,15) (13) 과 동일합니다. 아래의 allocator 사용 참고 를 참조하십시오.
16) 범위 rg 의 내용으로 컨테이너 어댑터를 생성합니다. 먼저 (10) 을 위임 생성자 로 사용합니다. 그런 다음 c 를 rg 의 내용으로 초기화합니다. 마치 insert_range ( std:: forward < R > ( rg ) ) ; 와 같이 수행됩니다.
17) (16) 와 동일하며 이를 delegating constructor 로 사용합니다.
18,19) (16) 과 동일합니다. 아래의 allocator usage note 를 참조하십시오.
20) 범위 [ first , last ) 의 내용으로 기반 컨테이너들을 insert ( first, last ) 를 사용하는 것처럼 구성합니다.
21,22) (20) 와 동일합니다. 아래의 allocator usage note 를 참조하십시오.
23) 초기화자 리스트 생성자 . (13) 을 위임 생성자 로 사용하여 초기화 리스트 init 의 내용으로 기반 컨테이너를 생성합니다.
24,25) (23) 와 동일합니다. 아래의 allocator 사용 참고 를 참조하십시오.
26) 초기화자 리스트 생성자 . 기본 컨테이너를 초기화 리스트 init 의 내용으로 생성하며, (20) 을 위임 생성자 로 사용합니다.
27,28) (26) 와 같이 저장합니다. 아래의 allocator usage note 를 참조하십시오.

오버로드 참고 사항 (13-15,20-22) : 만약 [ first , last ) 가 유효한 범위 가 아닐 경우, 동작은 정의되지 않습니다.

Note for overloads (4-6,13-19,23-25) : If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844 ).

목차

할당자 사용 참고 사항

생성자들 (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) 은 해당하는 비-할당자 생성자들과 동일하지만, 기반 컨테이너들 c.keys 와 c.values 가 사용-할당자 생성 으로 구성된다는 점이 다릅니다. 이러한 오버로드들은 std:: uses_allocator_v < container_type, Allocator > 가 true 인 경우에만 오버로드 해결에 참여합니다.

매개변수

key_cont - 기본 키 컨테이너를 초기화하는 데 사용할 소스 컨테이너
mapped_cont - 기본 값 컨테이너를 초기화하는 데 사용할 소스 컨테이너
other - 기본 컨테이너의 요소를 초기화하는 데 사용할 다른 flat_map 소스
alloc - 기본 컨테이너의 모든 메모리 할당에 사용할 할당자
comp - 키 비교에 사용할 함수 객체
first, last - 복사할 요소의 소스 범위 를 정의하는 반복자 쌍
init - 기본 컨테이너의 요소를 초기화하는 데 사용할 초기화자 목록
rg - 기본 컨테이너를 초기화하는 데 사용할 소스 컨테이너 호환 범위 (즉, 요소가 value_type 으로 변환 가능한 input_range )
fr - 포함된 멤버가 범위 생성되어야 함을 나타내는 구분 태그
s - 입력 시퀀스가 value_comp() 에 대해 정렬되고 모든 요소가 고유함을 나타내는 구분 태그
타입 요구사항
-
InputIt 는 LegacyInputIterator 요구사항을 충족해야 합니다.
-
Compare 는 Compare 요구사항을 충족해야 합니다.
-
Allocator 는 Allocator 요구사항을 충족해야 합니다.

복잡도

1) 상수.
2) 크기가 other 에 대해 선형적입니다.
3) 래핑된 컨테이너의 해당 이동 생성자와 동일합니다. 즉, cont 의 크기에 대해 상수 시간 또는 선형 시간이 소요됩니다.
4-6) N 에 대해 선형 - cont 가 value_comp() 에 따라 정렬된 경우, 그렇지 않으면 𝓞(N·log(N)) , 여기서 N 는 이 호출 전 key_cont. size ( ) 의 값입니다.
7-9) 래핑된 컨테이너의 해당 이동 생성자와 동일하며, 즉 cont 의 크기에 대해 상수 또는 선형 시간 복잡도를 가집니다.
10-12) 상수.
13-15) 입력 범위 [ first , last ) 가 value_comp() 에 대해 정렬된 경우 N 에 선형적이며, 그렇지 않으면 𝓞(N·log(N)) 입니다. 여기서 N 는 이 호출 전 key_cont. size ( ) 의 값입니다.
16-19) 입력 범위 rg 가 value_comp() 에 대해 정렬된 경우 N 에 선형적이며, 그렇지 않으면 𝓞(N·log(N)) 입니다. 여기서 N 은 이 호출 전 key_cont. size ( ) 의 값입니다.
20-22) [ first , last ) 의 크기에 선형적입니다.
23-25) N 에 대해 선형적이며, init 의 요소들이 value_comp() 에 대해 정렬된 경우, 그렇지 않으면 𝓞(N·log(N)) , 여기서 N 은 이 호출 전 key_cont. size ( ) 의 값입니다.
26-28) 크기에 대해 선형 init .

예외

Allocator::allocate 에 대한 호출은 예외를 발생시킬 수 있습니다.

참고 사항

컨테이너 이동 생성 후 (오버로드 ( 3 ) ), other 에 대한 참조, 포인터, 및 반복자(끝 반복자 제외)는 유효하지만, 이제는 * this 에 있는 요소들을 참조합니다. 현재 표준은 [container.reqmts]/67 의 포괄적 문장을 통해 이 보장을 제공하며, LWG 이슈 2321 을 통해 더 직접적인 보장이 검토 중입니다.

예제

이 섹션은 불완전합니다
이유: 예제 없음

참고 항목

컨테이너 어댑터에 값을 할당합니다
(public member function)