std::deque::operator=

`deque& operator=( const deque& other );`	(1)
	(2)
`deque& operator=( deque&& other );`			( C++11) ( C++17)
`deque& operator=( deque&& other ) noexcept(/* */);`			( C++17)
`deque& operator=( std::initializer_list<T> 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) *this ilist.

2)

noexcept:

noexcept(std::allocator_traits<Allocator>::is_always_equal::value)

( C++17)

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

[edit]

operator= , std::deque :

#include <deque>
#include <iostream>

void display_sizes(char const* comment,
                   const std::deque<int>& nums1,
                   const std::deque<int>& nums2,
                   const std::deque<int>& nums3)
{
    std::cout << comment
              << " nums1: " << nums1.size() << ','
              << " nums2: " << nums2.size() << ','
              << " nums3: " << nums3.size() << '\n';
}

void display(char const* comment, const std::deque<int>& v)
{
    std::cout << comment << "{ ";
    for (int e : v) {
        std::cout << e << ' ';
    }
    std::cout << "}\n";
}

int main()
{
    std::deque<int> nums1 {3, 1, 4, 6, 5, 9};
    std::deque<int> nums2;
    std::deque<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, 2, 3};

    display("  initializer_list \n nums3 = ", nums3);
}

:

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

.

()	`deque` (public -) []
assign	(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)

-
,


-
deque::deque
deque::~deque
deque::operator=
deque::assign
deque::assign_range (C++23)
deque::get_allocator

deque::at
deque::operator[]
deque::front
deque::back

deque::begindeque::cbegin (C++11)
deque::enddeque::cend (C++11)
deque::rbegindeque::crbegin (C++11)
deque::renddeque::crend (C++11)

deque::empty
deque::size
deque::max_size
deque::shrink_to_fit (DR*)

deque::clear
deque::insert
deque::insert_range (C++23)
deque::emplace
deque::erase
deque::push_front
deque::emplace_front
deque::prepend_range (C++23)
deque::pop_front
deque::push_back
deque::emplace_back (C++11)
deque::append_range (C++23)
deque::pop_back
deque::resize
deque::swap
,
std::swap
eraseerase_if (C++20)(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::deque::operator=

.