Namespaces
Variants

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

    From ko.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 issue 2321을 통해 더 직접적인 보장이 고려 중입니다.

    예제

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

    참고 항목

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