std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::operator=
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Containers library
(C++17)
(C++11)
(C++26)
(C++26)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++23)
(C++23)
(C++23)
(C++23)
(C++20)
(C++23)
Tables
std::flat_map
flat_map::operator=
flat_map& operator=( const flat_map& other );
(1)
(since C++23) (implicitly declared)
flat_map& operator=( flat_map&& other );
(2)
(since C++23) (implicitly declared)
flat_map& operator=( std::initializer_list <value_type> ilist );
(3)
(since C++23)
Replaces the contents of the container adaptor with the contents of given argument.
1) Copy assignment operator. Replaces the contents with a copy of the contents of other. Effectively calls c = other.c; comp = other.comp;.
2) Move assignment operator. Replaces the contents with those of other using move semantics. Effectively calls c = std::move(other.c); comp = std::move(other.comp);.
3) Replaces the contents with those identified by initializer list ilist.
[edit] Parameters
other
-
another container adaptor to be used as source
ilist
-
initializer list to be used as source
[edit] Return value
*this
[edit] Complexity
1,2) Equivalent to that of operator= of the underlying
container.
3) Linear in the size of *this and ilist.
[edit] Example
Run this code
#include <flat_map> #include <initializer_list> #include <print> #include <utility> int main() { std::flat_map <int, int> x{{1, 1}, {2, 2}, {3, 3}}, y, z; const auto w = {std::pair <const int, int>{4, 4}, {5, 5}, {6, 6}, {7, 7}}; std::println ("Initially:"); std::println ("x = {}", x); std::println ("y = {}", y); std::println ("z = {}", z); y = x; // overload (1) std::println ("Copy assignment copies data from x to y:"); std::println ("x = {}", x); std::println ("y = {}", y); z = std::move(x); // overload (2) std::println ("Move assignment moves data from x to z, modifying both x and z:"); std::println ("x = {}", x); std::println ("z = {}", z); z = w; // overload (3) std::println ("Assignment of initializer_list w to z:"); std::println ("w = {}", w); std::println ("z = {}", z); }
Output:
Initially:
x = {1: 1, 2: 2, 3: 3}
y = {}
z = {}
Copy assignment copies data from x to y:
x = {1: 1, 2: 2, 3: 3}
y = {1: 1, 2: 2, 3: 3}
Move assignment moves data from x to z, modifying both x and z:
x = {}
z = {1: 1, 2: 2, 3: 3}
Assignment of initializer_list w to z:
w = {4: 4, 5: 5, 6: 6, 7: 7}
z = {4: 4, 5: 5, 6: 6, 7: 7}