std::map::operator=

`map& operator=( const map& other );`	(1)
	(2)
`map& operator=( map&& other );`			( C++11) ( C++17)
`map& operator=( map&& other ) noexcept(/* */);`			( C++17)
`map& operator=( std::initializer_list<value_type> ilist );`		(3)	( C++11)

1) . other. std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value true, . , *this , other . ( C++11).

2) . other, (.. other ). other , . std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value true, . false , , , , . *this .

3) ilist.

other		,
ilist		,

*this

1) *this other.

2) *this, , , *this other.

3)

O(NlogN)

,

N

size() + ilist.size(). ilist - value_comp().

2)

noexcept:

noexcept(std::allocator_traits<Allocator>::is_always_equal::value && std::is_nothrow_move_assignable<Compare>::value)

( C++17)

( (2)), , , , ( end ) other , , *this. [container.requirements.general]/12, [lwg-2321].

[edit]

operator= , std::map :

#include <map>
#include <iostream>
 
void display_sizes(char const* comment,
                   const std::map<int, int>& nums1,
                   const std::map<int, int>& nums2,
                   const std::map<int, int>& nums3)
{
    std::cout << comment
              << " nums1: " << nums1.size() << ','
              << " nums2: " << nums2.size() << ','
              << " nums3: " << nums3.size() << '\n';
}
 
void display(char const* comment, const std::map<int, int>& v)
{
    std::cout << comment << "{ ";
    for (const auto &p : v) {
        std::cout << "{" << p.first << ", " << p.second << "} ";
    }
    std::cout << "}\n";
}
 
int main()
{
    std::map<int, int> nums1 {{3, 1}, {4, 1}, {5, 9}, 
                              {6, 1}, {7, 1}, {8, 9}};
    std::map<int, int> nums2;
    std::map<int, int> nums3;
 
    display_sizes(":\n", nums1, nums2, nums3);
 
    //     nums1  nums2
    nums2 = nums1;
 
    display_sizes(" :\n", nums1, nums2, nums3);
 
    //      nums1  nums3,
    // ,  nums1,   nums3
    nums3 = std::move(nums1);
 
    display_sizes("  :\n", nums1, nums2, nums3);
 
    display(" nums3 = ", nums3);
 
    //        nums3
    nums3 = {{1, 3}, {2, 2}, {3, 1}};
 
    display("  initializer_list \n nums3 = ", nums3);
}

:

:
 nums1: 6, nums2: 0, nums3: 0
 :
 nums1: 6, nums2: 6, nums3: 0
  :
 nums1: 0, nums2: 6, nums3: 6
 nums3 = { {3, 1} {4, 1} {5, 9} {6, 1} {7, 1} {8, 9} }
  initializer_list 
 nums3 = { {1, 3} {2, 2} {3, 1} }

.

()	`map` (public -) []







(C++20)

(C++20)
(C++11)





(C++20)


/

(C++11)
(C++11)
(C++11)
(C++17)


array (C++11)
vector
vector<bool>
deque
forward_list (C++11)
list

set
multiset
map
multimap

unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)

stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)

span (C++20)
mdspan (C++23)

-
,


map::map
map::~map
map::operator=
map::get_allocator

map::at
map::operator[]

map::beginmap::cbegin (C++11)
map::endmap::cend (C++11)
map::rbeginmap::crbegin (C++11)
map::rendmap::crend (C++11)

map::empty
map::size
map::max_size

map::clear
map::insert
map::insert_range (C++23)
map::insert_or_assign (C++17)
map::emplace (C++11)
map::emplace_hint (C++11)
map::try_emplace (C++17)
map::erase
map::swap
map::extract (C++17)
map::merge (C++17)

map::count
map::find
map::contains (C++20)
map::equal_range
map::lower_bound
map::upper_bound

map::key_comp
map::value_comp
,
std::swap
erase_if (C++20)
operator==operator!=operator<operator>operator<=operator>=operator<=> ( C++20)( C++20)( C++20)( C++20)( C++20)(C++20)
(C++17)

cppreference.com

std::map::operator=

.